{"matchId":"58807581","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-08T08:06:00Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"2042:5212:1:-:0;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;-1:-1:-1;;;;;2042:5212:1;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2042:5212:1;;;;;;;;1857:1:0;-1:-1:-1;1857:1:0;3180:18:1;;2042:5212;;3220:24;;2042:5212;;;;;;;;3220:24;2042:5212;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;-1:-1:-1;2042:5212:1;;;;;;-1:-1:-1;2042:5212:1;;;;;-1:-1:-1;2042:5212:1","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220f10f171434fbeb15f5959318ebb3db2f9437d259b8406cc5b180ac634594b06564736f6c63430008180033","offset":3048}},"transformations":[{"type":"insert","offset":3101,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x0000000000000000000000008b8427c7d11103125fe9d1bc45eba072fc61d947"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"2042:5212:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2042:5212:1;;;;;;;;;;;;;;5169:3;;2042:5212;;;;;;;;5169:21;;;;;2042:5212;5169:21;;2042:5212;5169:21;;;;;;;;;2042:5212;5169:21;;;2042:5212;5205:13;;;;2042:5212;5200:113;5220:7;;;;;;2042:5212;;;;;;;;5229:3;2042:5212;;-1:-1:-1;;;5267:34:1;;-1:-1:-1;;;;;2042:5212:1;;5267:34;;;2042:5212;;;;;;;;;;;;;;;;;;;;5267:34;;2042:5212;;;;;;5267:34;;;;;;;;;;2042:5212;5267:34;;;5229:3;5257:45;2042:5212;5257:45;;5248:54;5257:45;;:::i;:::-;5248:54;;:::i;:::-;5229:3;2042:5212;5205:13;;;;;;5267:34;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;;5267:34;;2042:5212;;;;5267:34;;;;;;2042:5212;;;;;;;;;5169:21;;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;5169:21;;;;;;;;;;2042:5212;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;4598:25;2042:5212;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;2466:103:0;;:::i;:::-;2042:5212:1;;-1:-1:-1;;;6629:25:1;;6643:10;6629:25;;;2042:5212;;;6629:25;;2042:5212;6629:3;-1:-1:-1;;;;;2042:5212:1;6629:25;2042:5212;;;;6629:25;;;;;;;2042:5212;6629:25;;;2042:5212;6664:13;2042:5212;6692:13;2042:5212;6707:7;;;;;;6643:10;7219:26;6643:10;;7168:36;2042:5212;6643:10;;;;;7125:33;;;;:::i;:::-;;7168:36;:::i;:::-;2042:5212;;;;6643:10;7219:26;;2042:5212;;;;6716:3;2042:5212;;-1:-1:-1;;;6753:38:1;;6643:10;6753:38;;;2042:5212;;;;;;;;;6643:10;;2042:5212;;;;;;6753:38;;;;;;;;;;2042:5212;6753:38;;;6716:3;2042:5212;;;;6809:7;2042:5212;;;;;;;;6805:287;;6716:3;;2042:5212;;6692:13;;6805:287;6861:52;2042:5212;;;;;;;;;6861:52;;:::i;:::-;2042:5212;;;;6948:8;;;;;6944:134;;6805:287;;;;;;6944:134;6980:13;;;;;;;;:::i;:::-;2042:5212;-1:-1:-1;;;;;;2042:5212:1;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;7015:44;2042:5212;;;;;;7015:44;:::i;:::-;2042:5212;;6944:134;;;;;;2042:5212;;;;;;;;;;;;6753:38;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;6753:38;;;;;;;;;2042:5212;;;;;;;;;6629:25;;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;6629:25;;;;;;;;;;2042:5212;;;;;;;;;;-1:-1:-1;2042:5212:1;;;-1:-1:-1;;2042:5212:1;;;;3065:47;3073:10;3095:3;-1:-1:-1;;;;;2042:5212:1;3073:26;3065:47;:::i;:::-;3592:11;2042:5212;3592:15;;;2042:5212;;3661:9;2042:5212;;3661:9;;2042:5212;;;2125:8;;2042:5212;3661:9;2042:5212;;;;;;3712:47;2042:5212;3631:66;2042:5212;;3631:66;2042:5212;3631:66;:::i;:::-;2042:5212;3631:66;2042:5212;;;3661:9;;2042:5212;;;;;;3712:47;2042:5212;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;;;;;;;;;;3065:47;3073:10;3095:3;-1:-1:-1;;;;;2042:5212:1;3073:26;3065:47;:::i;:::-;2042:5212;;;4176:7;2042:5212;;;;;;;;;;;;;4176:7;2042:5212;;;;;;;;;;;;;;;;4253:16;2042:5212;;;;;;;;;;;;;;4378:16;2042:5212;;;;;;;;;;4409:33;2042:5212;;;;4378:16;2042:5212;;;;;4409:33;2042:5212;;;;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;-1:-1:-1;2042:5212:1;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;;;;2534:51;2042:5212;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;5445:21;2042:5212;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2466:103:0;;;;;:::i;:::-;2042:5212:1;;-1:-1:-1;;;;;5892:3:1;2042:5212;;;;5801:19;;;;;;5916:10;6368:26;5916:10;;6317:36;2042:5212;5916:10;;;;;6274:33;;;;:::i;5822:3::-;2042:5212;;;;;;;;;;;;;5892:20;;;;;;2042:5212;5892:20;;;;;;;;;;;;2042:5212;5892:20;;;5822:3;5916:10;;;2042:5212;;5892:34;2042:5212;;;;;;;;;;;;;;5954:287;;5822:3;;2042:5212;;5786:13;;5954:287;6010:52;2042:5212;;;;;;;;;6010:52;;:::i;:::-;2042:5212;;;;6097:8;;;;;6093:134;;5954:287;;;;;;6093:134;6129:13;;;;;;;;:::i;:::-;2042:5212;-1:-1:-1;;;;;;2042:5212:1;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;6164:44;2042:5212;;;;;;6164:44;:::i;:::-;2042:5212;;6093:134;;;;;;2042:5212;;;;;;;;;;;;;-1:-1:-1;2042:5212:1;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;5892:20;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;;;;;;;;5892:20;;;;;;;;;2042:5212;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;2140:33;-1:-1:-1;;;;;2042:5212:1;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;2438:26;2042:5212;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;;;;;;2788:39;2042:5212;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;:::i;:::-;;;;-1:-1:-1;2042:5212:1;;;;:::o;:::-;;;:::o;:::-;;;;:::o;:::-;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;4797:197;-1:-1:-1;2042:5212:1;4878:7;2042:5212;;;;-1:-1:-1;2042:5212:1;;;4877:17;4873:31;;4922:52;:25;2042:5212;4950:15;2042:5212;;;-1:-1:-1;2042:5212:1;;4922:52;;:::i;:::-;2042:5212;;4797:197;:::o;4873:31::-;-1:-1:-1;4896:8:1;:::o;2575:307:0:-;1899:1;2702:7;2042:5212:1;2702:18:0;2698:86;;1899:1;2702:7;2042:5212:1;2575:307:0:o;2698:86::-;2042:5212:1;;-1:-1:-1;;;2743:30:0;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220f10f171434fbeb15f5959318ebb3db2f9437d259b8406cc5b180ac634594b06564736f6c63430008180033","offset":2824}},"immutableReferences":{"105":[{"start":243,"length":32},{"start":681,"length":32},{"start":1177,"length":32},{"start":1415,"length":32},{"start":1885,"length":32},{"start":2332,"length":32}]},"transformations":[{"id":"105","type":"replace","offset":243,"reason":"immutable"},{"id":"105","type":"replace","offset":681,"reason":"immutable"},{"id":"105","type":"replace","offset":1177,"reason":"immutable"},{"id":"105","type":"replace","offset":1415,"reason":"immutable"},{"id":"105","type":"replace","offset":1885,"reason":"immutable"},{"id":"105","type":"replace","offset":2332,"reason":"immutable"}],"transformationValues":{"immutables":{"105":"0x0000000000000000000000008b8427c7d11103125fe9d1bc45eba072fc61d947"}}},"deployment":{"transactionHash":"0x23e4d796d98744170286da157373cfc77653637bf6e867759b5bc3a89d352b4b","blockNumber":"132357441","transactionIndex":"30","deployer":"0xcbCadC7c9897d21FA6E3a8f941f9f271a39598E3"},"sources":{"DividendPool.sol":{"content":"// SPDX-License-Identifier: MIT\n// DividendPool — holds 20% of DIVIDEND's paid-mint fees (in BNB) and\n// pays them out to NFT holders as dividends. Magnified-dividends-\n// per-share accounting (MAGNITUDE = 2**128), the standard pattern for\n// per-token dividend trackers:\n//   * 1 PAID NFT = 1 share. ONLY paid mints earn shares; free mints\n//     earn 0 shares and dev reserve mints earn NO shares and are not\n//     counted. (Rule change 2026-11-08, Faiz: \"bikin yang free ga\n//     dapat dividen. Pool nya di bagikan hanya untuk yang bayar\".)\n//   * The NFT contract calls notifyMint(tokenId) for each new PAID\n//     token BEFORE depositing the mint's 20% fee, so a token earns\n//     from its own mint's deposit onward and NEVER retroactively.\n//   * claimedPerShare starts equal to startingPerShare, so a fresh\n//     mint's claimable is 0. On claim, claimedPerShare increases by\n//     owed * MAGNITUDE (the < 1 wei remainder per token is preserved,\n//     not forfeited — only integer-division dust of a few wei can\n//     remain in the pool).\n//   * Shares are per-tokenId, so unclaimed dividends travel with the\n//     token when it is transferred. No action is needed on transfer.\n//   * NO owner withdrawal: the pool's BNB belongs to holders. There is\n//     no sweep/withdraw function. Faiz's 80% never enters the pool.\n//   * deposit() and notifyMint() are callable ONLY by the NFT contract.\n// SOURCIFY VERIFICATION: self-contained apart from OpenZeppelin 5.4.0\n// imports. Compile settings to reproduce the deployed bytecode exactly:\n//   solc 0.8.24+commit.e11b9ed9\n//   optimizer: enabled, 200 runs\n//   viaIR: true\n//   EVM version: default (cancun for solc 0.8.24)\npragma solidity ^0.8.24;\n\nimport \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\n\ninterface IDividendNFT {\n    function ownerOf(uint256 tokenId) external view returns (address);\n    function balanceOf(address owner) external view returns (uint256);\n    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);\n}\n\ncontract DividendPool is ReentrancyGuard {\n    uint256 public constant MAGNITUDE = 2 ** 128;\n\n    IDividendNFT public immutable nft;\n\n    /// @notice Magnified dividends per share, in wei * MAGNITUDE.\n    uint256 public magnifiedDividendPerShare;\n    /// @notice Number of dividend-eligible NFTs minted so far\n    /// (paid mints only; free mints and dev reserve mints are\n    /// excluded).\n    uint256 public totalShares;\n\n    /// @notice magnifiedDividendPerShare at the token's mint.\n    mapping(uint256 => uint256) public startingPerShare;\n    /// @notice magnifiedDividendPerShare already claimed by the token.\n    mapping(uint256 => uint256) public claimedPerShare;\n    /// @notice Whether the token is a dividend share (public mint).\n    mapping(uint256 => bool) public isShare;\n\n    event Deposited(uint256 amount, uint256 magnifiedDividendPerShare);\n    event ShareMinted(uint256 indexed tokenId, uint256 totalShares);\n    event Claimed(address indexed claimer, uint256 amount);\n\n    modifier onlyNft() {\n        require(msg.sender == address(nft), \"Only NFT\");\n        _;\n    }\n\n    constructor(address nft_) {\n        require(nft_ != address(0), \"Bad NFT\");\n        nft = IDividendNFT(nft_);\n    }\n\n    /// @notice Receive a dividend deposit from the NFT contract\n    /// (20% of a paid mint's fee). Increases the magnified dividend\n    /// per share. Reverts if no shares exist yet — cannot happen in\n    /// practice: mint() notifies the new shares before depositing.\n    function deposit() external payable onlyNft {\n        require(totalShares > 0, \"No shares\");\n        magnifiedDividendPerShare += (msg.value * MAGNITUDE) / totalShares;\n        emit Deposited(msg.value, magnifiedDividendPerShare);\n    }\n\n    /// @notice Register a newly minted PAID token as a dividend\n    /// share. Its startingPerShare is the current per-share value, so\n    /// it claims nothing retroactive. Called by the NFT contract only,\n    /// once per token, before the mint's fee is deposited. Free mints\n    /// and dev reserve mints are never registered.\n    function notifyMint(uint256 tokenId) external onlyNft {\n        require(!isShare[tokenId], \"Already share\");\n        isShare[tokenId] = true;\n        startingPerShare[tokenId] = magnifiedDividendPerShare;\n        claimedPerShare[tokenId] = magnifiedDividendPerShare;\n        totalShares += 1;\n        emit ShareMinted(tokenId, totalShares);\n    }\n\n    /// @notice Magnified dividends per share (the accumulator).\n    function dividendsPerShare() external view returns (uint256) {\n        return magnifiedDividendPerShare;\n    }\n\n    /// @notice BNB claimable by one token. 0 for free-mint and\n    /// dev-reserve tokens (never registered as shares) and for tokens\n    /// with nothing new.\n    function claimable(uint256 tokenId) public view returns (uint256) {\n        if (!isShare[tokenId]) return 0;\n        return (magnifiedDividendPerShare - claimedPerShare[tokenId]) / MAGNITUDE;\n    }\n\n    /// @notice Total BNB claimable by all tokens owned by `owner_`.\n    function claimableFor(address owner_) external view returns (uint256 total) {\n        uint256 bal = nft.balanceOf(owner_);\n        for (uint256 i = 0; i < bal; i++) {\n            total += claimable(nft.tokenOfOwnerByIndex(owner_, i));\n        }\n    }\n\n    /// @notice BNB currently held by the pool.\n    function poolBalance() external view returns (uint256) {\n        return address(this).balance;\n    }\n\n    /// @notice Claim the dividends of `tokenIds`. Caller must own each\n    /// token. Pays the exact sum; claiming twice in a row pays 0 the\n    /// second time (a zero claim succeeds and transfers 0).\n    function claim(uint256[] calldata tokenIds) external nonReentrant {\n        uint256 total;\n        for (uint256 i = 0; i < tokenIds.length; i++) {\n            uint256 tokenId = tokenIds[i];\n            require(nft.ownerOf(tokenId) == msg.sender, \"Not owner\");\n            if (isShare[tokenId]) {\n                uint256 owed = (magnifiedDividendPerShare - claimedPerShare[tokenId]) / MAGNITUDE;\n                if (owed > 0) {\n                    total += owed;\n                    claimedPerShare[tokenId] += owed * MAGNITUDE;\n                }\n            }\n        }\n        (bool ok, ) = msg.sender.call{value: total}(\"\");\n        require(ok, \"Claim transfer failed\");\n        emit Claimed(msg.sender, total);\n    }\n\n    /// @notice Claim the dividends of ALL tokens the caller owns.\n    /// Non-share tokens (free mints, dev reserve) contribute 0 and\n    /// are skipped.\n    function claimAll() external nonReentrant {\n        uint256 bal = nft.balanceOf(msg.sender);\n        uint256 total;\n        for (uint256 i = 0; i < bal; i++) {\n            uint256 tokenId = nft.tokenOfOwnerByIndex(msg.sender, i);\n            if (isShare[tokenId]) {\n                uint256 owed = (magnifiedDividendPerShare - claimedPerShare[tokenId]) / MAGNITUDE;\n                if (owed > 0) {\n                    total += owed;\n                    claimedPerShare[tokenId] += owed * MAGNITUDE;\n                }\n            }\n        }\n        (bool ok, ) = msg.sender.call{value: total}(\"\");\n        require(ok, \"Claim transfer failed\");\n        emit Claimed(msg.sender, total);\n    }\n}\n"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\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 */\nabstract contract ReentrancyGuard {\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    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = 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    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = 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        _status = 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 _status == ENTERED;\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.24+commit.e11b9ed9","compilerSettings":{"viaIR":true,"optimizer":{"runs":200,"enabled":true}},"name":"DividendPool","fullyQualifiedName":"DividendPool.sol:DividendPool"},"abi":[{"type":"constructor","inputs":[{"name":"nft_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"Claimed","type":"event","inputs":[{"name":"claimer","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Deposited","type":"event","inputs":[{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"magnifiedDividendPerShare","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"ShareMinted","type":"event","inputs":[{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"totalShares","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MAGNITUDE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claim","type":"function","inputs":[{"name":"tokenIds","type":"uint256[]","internalType":"uint256[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimAll","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimable","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claimableFor","type":"function","inputs":[{"name":"owner_","type":"address","internalType":"address"}],"outputs":[{"name":"total","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claimedPerShare","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"deposit","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"dividendsPerShare","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"isShare","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"magnifiedDividendPerShare","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"nft","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IDividendNFT"}],"stateMutability":"view"},{"name":"notifyMint","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"poolBalance","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"startingPerShare","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalShares","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.24+commit.e11b9ed9"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"nft_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"claimer","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"magnifiedDividendPerShare","type":"uint256"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalShares","type":"uint256"}],"name":"ShareMinted","type":"event"},{"inputs":[],"name":"MAGNITUDE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"claimable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner_","type":"address"}],"name":"claimableFor","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"claimedPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"dividendsPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"isShare","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"magnifiedDividendPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nft","outputs":[{"internalType":"contract IDividendNFT","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"notifyMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"poolBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"startingPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],"devdoc":{"errors":{"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}]},"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{"claim(uint256[])":{"notice":"Claim the dividends of `tokenIds`. Caller must own each token. Pays the exact sum; claiming twice in a row pays 0 the second time (a zero claim succeeds and transfers 0)."},"claimAll()":{"notice":"Claim the dividends of ALL tokens the caller owns. Non-share tokens (free mints, dev reserve) contribute 0 and are skipped."},"claimable(uint256)":{"notice":"BNB claimable by one token. 0 for free-mint and dev-reserve tokens (never registered as shares) and for tokens with nothing new."},"claimableFor(address)":{"notice":"Total BNB claimable by all tokens owned by `owner_`."},"claimedPerShare(uint256)":{"notice":"magnifiedDividendPerShare already claimed by the token."},"deposit()":{"notice":"Receive a dividend deposit from the NFT contract (20% of a paid mint's fee). Increases the magnified dividend per share. Reverts if no shares exist yet — cannot happen in practice: mint() notifies the new shares before depositing."},"dividendsPerShare()":{"notice":"Magnified dividends per share (the accumulator)."},"isShare(uint256)":{"notice":"Whether the token is a dividend share (public mint)."},"magnifiedDividendPerShare()":{"notice":"Magnified dividends per share, in wei * MAGNITUDE."},"notifyMint(uint256)":{"notice":"Register a newly minted PAID token as a dividend share. Its startingPerShare is the current per-share value, so it claims nothing retroactive. Called by the NFT contract only, once per token, before the mint's fee is deposited. Free mints and dev reserve mints are never registered."},"poolBalance()":{"notice":"BNB currently held by the pool."},"startingPerShare(uint256)":{"notice":"magnifiedDividendPerShare at the token's mint."},"totalShares()":{"notice":"Number of dividend-eligible NFTs minted so far (paid mints only; free mints and dev reserve mints are excluded)."}},"version":1}},"settings":{"compilationTarget":{"DividendPool.sol":"DividendPool"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[],"viaIR":true},"sources":{"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"keccak256":"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3","license":"MIT","urls":["bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a","dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA"]},"DividendPool.sol":{"keccak256":"0x2593097b24a10ec7ad6457e41ca73923abe8255a7625c7b4bd19a5aa5915d10f","license":"MIT","urls":["bzz-raw://791534d64111cfb26cf087047f1e6b81ec9ef4be58b4d7aa4c50b67c742a46f5","dweb:/ipfs/QmWbJy5yGK2RGJaqobe57Rxv8wTNHy3nKYFD5J1qLC3BWB"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_uint256,t_bool)":{"key":"t_uint256","label":"mapping(uint256 => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_uint256)":{"key":"t_uint256","label":"mapping(uint256 => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint256","astId":10,"label":"_status","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"1","type":"t_uint256","astId":108,"label":"magnifiedDividendPerShare","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"2","type":"t_uint256","astId":111,"label":"totalShares","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"3","type":"t_mapping(t_uint256,t_uint256)","astId":116,"label":"startingPerShare","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"4","type":"t_mapping(t_uint256,t_uint256)","astId":121,"label":"claimedPerShare","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"5","type":"t_mapping(t_uint256,t_bool)","astId":126,"label":"isShare","offset":0,"contract":"DividendPool.sol:DividendPool"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{"deposit()":{"notice":"Receive a dividend deposit from the NFT contract (20% of a paid mint's fee). Increases the magnified dividend per share. Reverts if no shares exist yet — cannot happen in practice: mint() notifies the new shares before depositing."},"claimAll()":{"notice":"Claim the dividends of ALL tokens the caller owns. Non-share tokens (free mints, dev reserve) contribute 0 and are skipped."},"poolBalance()":{"notice":"BNB currently held by the pool."},"totalShares()":{"notice":"Number of dividend-eligible NFTs minted so far (paid mints only; free mints and dev reserve mints are excluded)."},"claim(uint256[])":{"notice":"Claim the dividends of `tokenIds`. Caller must own each token. Pays the exact sum; claiming twice in a row pays 0 the second time (a zero claim succeeds and transfers 0)."},"isShare(uint256)":{"notice":"Whether the token is a dividend share (public mint)."},"claimable(uint256)":{"notice":"BNB claimable by one token. 0 for free-mint and dev-reserve tokens (never registered as shares) and for tokens with nothing new."},"dividendsPerShare()":{"notice":"Magnified dividends per share (the accumulator)."},"notifyMint(uint256)":{"notice":"Register a newly minted PAID token as a dividend share. Its startingPerShare is the current per-share value, so it claims nothing retroactive. Called by the NFT contract only, once per token, before the mint's fee is deposited. Free mints and dev reserve mints are never registered."},"claimableFor(address)":{"notice":"Total BNB claimable by all tokens owned by `owner_`."},"claimedPerShare(uint256)":{"notice":"magnifiedDividendPerShare already claimed by the token."},"startingPerShare(uint256)":{"notice":"magnifiedDividendPerShare at the token's mint."},"magnifiedDividendPerShare()":{"notice":"Magnified dividends per share, in wei * MAGNITUDE."}},"version":1},"devdoc":{"kind":"dev","errors":{"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}]},"methods":{},"version":1},"sourceIds":{"DividendPool.sol":{"id":1},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"id":0}},"additionalInput":null,"stdJsonInput":{"sources":{"DividendPool.sol":{"content":"// SPDX-License-Identifier: MIT\n// DividendPool — holds 20% of DIVIDEND's paid-mint fees (in BNB) and\n// pays them out to NFT holders as dividends. Magnified-dividends-\n// per-share accounting (MAGNITUDE = 2**128), the standard pattern for\n// per-token dividend trackers:\n//   * 1 PAID NFT = 1 share. ONLY paid mints earn shares; free mints\n//     earn 0 shares and dev reserve mints earn NO shares and are not\n//     counted. (Rule change 2026-11-08, Faiz: \"bikin yang free ga\n//     dapat dividen. Pool nya di bagikan hanya untuk yang bayar\".)\n//   * The NFT contract calls notifyMint(tokenId) for each new PAID\n//     token BEFORE depositing the mint's 20% fee, so a token earns\n//     from its own mint's deposit onward and NEVER retroactively.\n//   * claimedPerShare starts equal to startingPerShare, so a fresh\n//     mint's claimable is 0. On claim, claimedPerShare increases by\n//     owed * MAGNITUDE (the < 1 wei remainder per token is preserved,\n//     not forfeited — only integer-division dust of a few wei can\n//     remain in the pool).\n//   * Shares are per-tokenId, so unclaimed dividends travel with the\n//     token when it is transferred. No action is needed on transfer.\n//   * NO owner withdrawal: the pool's BNB belongs to holders. There is\n//     no sweep/withdraw function. Faiz's 80% never enters the pool.\n//   * deposit() and notifyMint() are callable ONLY by the NFT contract.\n// SOURCIFY VERIFICATION: self-contained apart from OpenZeppelin 5.4.0\n// imports. Compile settings to reproduce the deployed bytecode exactly:\n//   solc 0.8.24+commit.e11b9ed9\n//   optimizer: enabled, 200 runs\n//   viaIR: true\n//   EVM version: default (cancun for solc 0.8.24)\npragma solidity ^0.8.24;\n\nimport \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\n\ninterface IDividendNFT {\n    function ownerOf(uint256 tokenId) external view returns (address);\n    function balanceOf(address owner) external view returns (uint256);\n    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);\n}\n\ncontract DividendPool is ReentrancyGuard {\n    uint256 public constant MAGNITUDE = 2 ** 128;\n\n    IDividendNFT public immutable nft;\n\n    /// @notice Magnified dividends per share, in wei * MAGNITUDE.\n    uint256 public magnifiedDividendPerShare;\n    /// @notice Number of dividend-eligible NFTs minted so far\n    /// (paid mints only; free mints and dev reserve mints are\n    /// excluded).\n    uint256 public totalShares;\n\n    /// @notice magnifiedDividendPerShare at the token's mint.\n    mapping(uint256 => uint256) public startingPerShare;\n    /// @notice magnifiedDividendPerShare already claimed by the token.\n    mapping(uint256 => uint256) public claimedPerShare;\n    /// @notice Whether the token is a dividend share (public mint).\n    mapping(uint256 => bool) public isShare;\n\n    event Deposited(uint256 amount, uint256 magnifiedDividendPerShare);\n    event ShareMinted(uint256 indexed tokenId, uint256 totalShares);\n    event Claimed(address indexed claimer, uint256 amount);\n\n    modifier onlyNft() {\n        require(msg.sender == address(nft), \"Only NFT\");\n        _;\n    }\n\n    constructor(address nft_) {\n        require(nft_ != address(0), \"Bad NFT\");\n        nft = IDividendNFT(nft_);\n    }\n\n    /// @notice Receive a dividend deposit from the NFT contract\n    /// (20% of a paid mint's fee). Increases the magnified dividend\n    /// per share. Reverts if no shares exist yet — cannot happen in\n    /// practice: mint() notifies the new shares before depositing.\n    function deposit() external payable onlyNft {\n        require(totalShares > 0, \"No shares\");\n        magnifiedDividendPerShare += (msg.value * MAGNITUDE) / totalShares;\n        emit Deposited(msg.value, magnifiedDividendPerShare);\n    }\n\n    /// @notice Register a newly minted PAID token as a dividend\n    /// share. Its startingPerShare is the current per-share value, so\n    /// it claims nothing retroactive. Called by the NFT contract only,\n    /// once per token, before the mint's fee is deposited. Free mints\n    /// and dev reserve mints are never registered.\n    function notifyMint(uint256 tokenId) external onlyNft {\n        require(!isShare[tokenId], \"Already share\");\n        isShare[tokenId] = true;\n        startingPerShare[tokenId] = magnifiedDividendPerShare;\n        claimedPerShare[tokenId] = magnifiedDividendPerShare;\n        totalShares += 1;\n        emit ShareMinted(tokenId, totalShares);\n    }\n\n    /// @notice Magnified dividends per share (the accumulator).\n    function dividendsPerShare() external view returns (uint256) {\n        return magnifiedDividendPerShare;\n    }\n\n    /// @notice BNB claimable by one token. 0 for free-mint and\n    /// dev-reserve tokens (never registered as shares) and for tokens\n    /// with nothing new.\n    function claimable(uint256 tokenId) public view returns (uint256) {\n        if (!isShare[tokenId]) return 0;\n        return (magnifiedDividendPerShare - claimedPerShare[tokenId]) / MAGNITUDE;\n    }\n\n    /// @notice Total BNB claimable by all tokens owned by `owner_`.\n    function claimableFor(address owner_) external view returns (uint256 total) {\n        uint256 bal = nft.balanceOf(owner_);\n        for (uint256 i = 0; i < bal; i++) {\n            total += claimable(nft.tokenOfOwnerByIndex(owner_, i));\n        }\n    }\n\n    /// @notice BNB currently held by the pool.\n    function poolBalance() external view returns (uint256) {\n        return address(this).balance;\n    }\n\n    /// @notice Claim the dividends of `tokenIds`. Caller must own each\n    /// token. Pays the exact sum; claiming twice in a row pays 0 the\n    /// second time (a zero claim succeeds and transfers 0).\n    function claim(uint256[] calldata tokenIds) external nonReentrant {\n        uint256 total;\n        for (uint256 i = 0; i < tokenIds.length; i++) {\n            uint256 tokenId = tokenIds[i];\n            require(nft.ownerOf(tokenId) == msg.sender, \"Not owner\");\n            if (isShare[tokenId]) {\n                uint256 owed = (magnifiedDividendPerShare - claimedPerShare[tokenId]) / MAGNITUDE;\n                if (owed > 0) {\n                    total += owed;\n                    claimedPerShare[tokenId] += owed * MAGNITUDE;\n                }\n            }\n        }\n        (bool ok, ) = msg.sender.call{value: total}(\"\");\n        require(ok, \"Claim transfer failed\");\n        emit Claimed(msg.sender, total);\n    }\n\n    /// @notice Claim the dividends of ALL tokens the caller owns.\n    /// Non-share tokens (free mints, dev reserve) contribute 0 and\n    /// are skipped.\n    function claimAll() external nonReentrant {\n        uint256 bal = nft.balanceOf(msg.sender);\n        uint256 total;\n        for (uint256 i = 0; i < bal; i++) {\n            uint256 tokenId = nft.tokenOfOwnerByIndex(msg.sender, i);\n            if (isShare[tokenId]) {\n                uint256 owed = (magnifiedDividendPerShare - claimedPerShare[tokenId]) / MAGNITUDE;\n                if (owed > 0) {\n                    total += owed;\n                    claimedPerShare[tokenId] += owed * MAGNITUDE;\n                }\n            }\n        }\n        (bool ok, ) = msg.sender.call{value: total}(\"\");\n        require(ok, \"Claim transfer failed\");\n        emit Claimed(msg.sender, total);\n    }\n}\n"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\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 */\nabstract contract ReentrancyGuard {\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    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = 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    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = 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        _status = 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 _status == ENTERED;\n    }\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"optimizer":{"runs":200,"enabled":true}}},"stdJsonOutput":{"sources":{"DividendPool.sol":{"id":1},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"id":0}},"contracts":{"DividendPool.sol":{"DividendPool":{"abi":[{"type":"constructor","inputs":[{"name":"nft_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"Claimed","type":"event","inputs":[{"name":"claimer","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Deposited","type":"event","inputs":[{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"magnifiedDividendPerShare","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"ShareMinted","type":"event","inputs":[{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"totalShares","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MAGNITUDE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claim","type":"function","inputs":[{"name":"tokenIds","type":"uint256[]","internalType":"uint256[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimAll","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimable","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claimableFor","type":"function","inputs":[{"name":"owner_","type":"address","internalType":"address"}],"outputs":[{"name":"total","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claimedPerShare","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"deposit","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"dividendsPerShare","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"isShare","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"magnifiedDividendPerShare","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"nft","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IDividendNFT"}],"stateMutability":"view"},{"name":"notifyMint","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"poolBalance","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"startingPerShare","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalShares","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.24+commit.e11b9ed9\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"nft_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"claimer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Claimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"magnifiedDividendPerShare\",\"type\":\"uint256\"}],\"name\":\"Deposited\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalShares\",\"type\":\"uint256\"}],\"name\":\"ShareMinted\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAGNITUDE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"tokenIds\",\"type\":\"uint256[]\"}],\"name\":\"claim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"claimable\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner_\",\"type\":\"address\"}],\"name\":\"claimableFor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"total\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"claimedPerShare\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"dividendsPerShare\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"isShare\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"magnifiedDividendPerShare\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nft\",\"outputs\":[{\"internalType\":\"contract IDividendNFT\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"notifyMint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"poolBalance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"startingPerShare\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}]},\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"claim(uint256[])\":{\"notice\":\"Claim the dividends of `tokenIds`. Caller must own each token. Pays the exact sum; claiming twice in a row pays 0 the second time (a zero claim succeeds and transfers 0).\"},\"claimAll()\":{\"notice\":\"Claim the dividends of ALL tokens the caller owns. Non-share tokens (free mints, dev reserve) contribute 0 and are skipped.\"},\"claimable(uint256)\":{\"notice\":\"BNB claimable by one token. 0 for free-mint and dev-reserve tokens (never registered as shares) and for tokens with nothing new.\"},\"claimableFor(address)\":{\"notice\":\"Total BNB claimable by all tokens owned by `owner_`.\"},\"claimedPerShare(uint256)\":{\"notice\":\"magnifiedDividendPerShare already claimed by the token.\"},\"deposit()\":{\"notice\":\"Receive a dividend deposit from the NFT contract (20% of a paid mint's fee). Increases the magnified dividend per share. Reverts if no shares exist yet — cannot happen in practice: mint() notifies the new shares before depositing.\"},\"dividendsPerShare()\":{\"notice\":\"Magnified dividends per share (the accumulator).\"},\"isShare(uint256)\":{\"notice\":\"Whether the token is a dividend share (public mint).\"},\"magnifiedDividendPerShare()\":{\"notice\":\"Magnified dividends per share, in wei * MAGNITUDE.\"},\"notifyMint(uint256)\":{\"notice\":\"Register a newly minted PAID token as a dividend share. Its startingPerShare is the current per-share value, so it claims nothing retroactive. Called by the NFT contract only, once per token, before the mint's fee is deposited. Free mints and dev reserve mints are never registered.\"},\"poolBalance()\":{\"notice\":\"BNB currently held by the pool.\"},\"startingPerShare(uint256)\":{\"notice\":\"magnifiedDividendPerShare at the token's mint.\"},\"totalShares()\":{\"notice\":\"Number of dividend-eligible NFTs minted so far (paid mints only; free mints and dev reserve mints are excluded).\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"DividendPool.sol\":\"DividendPool\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a\",\"dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA\"]},\"DividendPool.sol\":{\"keccak256\":\"0x2593097b24a10ec7ad6457e41ca73923abe8255a7625c7b4bd19a5aa5915d10f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://791534d64111cfb26cf087047f1e6b81ec9ef4be58b4d7aa4c50b67c742a46f5\",\"dweb:/ipfs/QmWbJy5yGK2RGJaqobe57Rxv8wTNHy3nKYFD5J1qLC3BWB\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{"deposit()":{"notice":"Receive a dividend deposit from the NFT contract (20% of a paid mint's fee). Increases the magnified dividend per share. Reverts if no shares exist yet — cannot happen in practice: mint() notifies the new shares before depositing."},"claimAll()":{"notice":"Claim the dividends of ALL tokens the caller owns. Non-share tokens (free mints, dev reserve) contribute 0 and are skipped."},"poolBalance()":{"notice":"BNB currently held by the pool."},"totalShares()":{"notice":"Number of dividend-eligible NFTs minted so far (paid mints only; free mints and dev reserve mints are excluded)."},"claim(uint256[])":{"notice":"Claim the dividends of `tokenIds`. Caller must own each token. Pays the exact sum; claiming twice in a row pays 0 the second time (a zero claim succeeds and transfers 0)."},"isShare(uint256)":{"notice":"Whether the token is a dividend share (public mint)."},"claimable(uint256)":{"notice":"BNB claimable by one token. 0 for free-mint and dev-reserve tokens (never registered as shares) and for tokens with nothing new."},"dividendsPerShare()":{"notice":"Magnified dividends per share (the accumulator)."},"notifyMint(uint256)":{"notice":"Register a newly minted PAID token as a dividend share. Its startingPerShare is the current per-share value, so it claims nothing retroactive. Called by the NFT contract only, once per token, before the mint's fee is deposited. Free mints and dev reserve mints are never registered."},"claimableFor(address)":{"notice":"Total BNB claimable by all tokens owned by `owner_`."},"claimedPerShare(uint256)":{"notice":"magnifiedDividendPerShare already claimed by the token."},"startingPerShare(uint256)":{"notice":"magnifiedDividendPerShare at the token's mint."},"magnifiedDividendPerShare()":{"notice":"Magnified dividends per share, in wei * MAGNITUDE."}},"version":1},"devdoc":{"kind":"dev","errors":{"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}]},"methods":{},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_uint256,t_bool)":{"key":"t_uint256","label":"mapping(uint256 => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_uint256)":{"key":"t_uint256","label":"mapping(uint256 => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint256","astId":10,"label":"_status","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"1","type":"t_uint256","astId":108,"label":"magnifiedDividendPerShare","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"2","type":"t_uint256","astId":111,"label":"totalShares","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"3","type":"t_mapping(t_uint256,t_uint256)","astId":116,"label":"startingPerShare","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"4","type":"t_mapping(t_uint256,t_uint256)","astId":121,"label":"claimedPerShare","offset":0,"contract":"DividendPool.sol:DividendPool"},{"slot":"5","type":"t_mapping(t_uint256,t_bool)","astId":126,"label":"isShare","offset":0,"contract":"DividendPool.sol:DividendPool"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"2042:5212:1:-:0;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;-1:-1:-1;;;;;2042:5212:1;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2042:5212:1;;;;;;;;1857:1:0;-1:-1:-1;1857:1:0;3180:18:1;;2042:5212;;3220:24;;2042:5212;;;;;;;;3220:24;2042:5212;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;-1:-1:-1;2042:5212:1;;;;;;-1:-1:-1;2042:5212:1;;;;;-1:-1:-1;2042:5212:1","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"2042:5212:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2042:5212:1;;;;;;;;;;;;;;5169:3;;2042:5212;;;;;;;;5169:21;;;;;2042:5212;5169:21;;2042:5212;5169:21;;;;;;;;;2042:5212;5169:21;;;2042:5212;5205:13;;;;2042:5212;5200:113;5220:7;;;;;;2042:5212;;;;;;;;5229:3;2042:5212;;-1:-1:-1;;;5267:34:1;;-1:-1:-1;;;;;2042:5212:1;;5267:34;;;2042:5212;;;;;;;;;;;;;;;;;;;;5267:34;;2042:5212;;;;;;5267:34;;;;;;;;;;2042:5212;5267:34;;;5229:3;5257:45;2042:5212;5257:45;;5248:54;5257:45;;:::i;:::-;5248:54;;:::i;:::-;5229:3;2042:5212;5205:13;;;;;;5267:34;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;;5267:34;;2042:5212;;;;5267:34;;;;;;2042:5212;;;;;;;;;5169:21;;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;5169:21;;;;;;;;;;2042:5212;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;4598:25;2042:5212;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;2466:103:0;;:::i;:::-;2042:5212:1;;-1:-1:-1;;;6629:25:1;;6643:10;6629:25;;;2042:5212;;;6629:25;;2042:5212;6629:3;-1:-1:-1;;;;;2042:5212:1;6629:25;2042:5212;;;;6629:25;;;;;;;2042:5212;6629:25;;;2042:5212;6664:13;2042:5212;6692:13;2042:5212;6707:7;;;;;;6643:10;7219:26;6643:10;;7168:36;2042:5212;6643:10;;;;;7125:33;;;;:::i;:::-;;7168:36;:::i;:::-;2042:5212;;;;6643:10;7219:26;;2042:5212;;;;6716:3;2042:5212;;-1:-1:-1;;;6753:38:1;;6643:10;6753:38;;;2042:5212;;;;;;;;;6643:10;;2042:5212;;;;;;6753:38;;;;;;;;;;2042:5212;6753:38;;;6716:3;2042:5212;;;;6809:7;2042:5212;;;;;;;;6805:287;;6716:3;;2042:5212;;6692:13;;6805:287;6861:52;2042:5212;;;;;;;;;6861:52;;:::i;:::-;2042:5212;;;;6948:8;;;;;6944:134;;6805:287;;;;;;6944:134;6980:13;;;;;;;;:::i;:::-;2042:5212;-1:-1:-1;;;;;;2042:5212:1;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;7015:44;2042:5212;;;;;;7015:44;:::i;:::-;2042:5212;;6944:134;;;;;;2042:5212;;;;;;;;;;;;6753:38;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;6753:38;;;;;;;;;2042:5212;;;;;;;;;6629:25;;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;6629:25;;;;;;;;;;2042:5212;;;;;;;;;;-1:-1:-1;2042:5212:1;;;-1:-1:-1;;2042:5212:1;;;;3065:47;3073:10;3095:3;-1:-1:-1;;;;;2042:5212:1;3073:26;3065:47;:::i;:::-;3592:11;2042:5212;3592:15;;;2042:5212;;3661:9;2042:5212;;3661:9;;2042:5212;;;2125:8;;2042:5212;3661:9;2042:5212;;;;;;3712:47;2042:5212;3631:66;2042:5212;;3631:66;2042:5212;3631:66;:::i;:::-;2042:5212;3631:66;2042:5212;;;3661:9;;2042:5212;;;;;;3712:47;2042:5212;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;;;;;;;;;;3065:47;3073:10;3095:3;-1:-1:-1;;;;;2042:5212:1;3073:26;3065:47;:::i;:::-;2042:5212;;;4176:7;2042:5212;;;;;;;;;;;;;4176:7;2042:5212;;;;;;;;;;;;;;;;4253:16;2042:5212;;;;;;;;;;;;;;4378:16;2042:5212;;;;;;;;;;4409:33;2042:5212;;;;4378:16;2042:5212;;;;;4409:33;2042:5212;;;;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;-1:-1:-1;2042:5212:1;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;;;;2534:51;2042:5212;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;5445:21;2042:5212;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2466:103:0;;;;;:::i;:::-;2042:5212:1;;-1:-1:-1;;;;;5892:3:1;2042:5212;;;;5801:19;;;;;;5916:10;6368:26;5916:10;;6317:36;2042:5212;5916:10;;;;;6274:33;;;;:::i;5822:3::-;2042:5212;;;;;;;;;;;;;5892:20;;;;;;2042:5212;5892:20;;;;;;;;;;;;2042:5212;5892:20;;;5822:3;5916:10;;;2042:5212;;5892:34;2042:5212;;;;;;;;;;;;;;5954:287;;5822:3;;2042:5212;;5786:13;;5954:287;6010:52;2042:5212;;;;;;;;;6010:52;;:::i;:::-;2042:5212;;;;6097:8;;;;;6093:134;;5954:287;;;;;;6093:134;6129:13;;;;;;;;:::i;:::-;2042:5212;-1:-1:-1;;;;;;2042:5212:1;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;;6164:44;2042:5212;;;;;;6164:44;:::i;:::-;2042:5212;;6093:134;;;;;;2042:5212;;;;;;;;;;;;;-1:-1:-1;2042:5212:1;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;5892:20;;;;;;;;;;;;;;;;:::i;:::-;;;2042:5212;;;;;;;;;;;;5892:20;;;;;;;;;2042:5212;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;2140:33;-1:-1:-1;;;;;2042:5212:1;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;2438:26;2042:5212;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;;;;;;;2788:39;2042:5212;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2042:5212:1;;;;;:::i;:::-;;;;-1:-1:-1;2042:5212:1;;;;:::o;:::-;;;:::o;:::-;;;;:::o;:::-;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;2042:5212:1;;;;;;;;;;;;-1:-1:-1;;;2042:5212:1;;;;;;;4797:197;-1:-1:-1;2042:5212:1;4878:7;2042:5212;;;;-1:-1:-1;2042:5212:1;;;4877:17;4873:31;;4922:52;:25;2042:5212;4950:15;2042:5212;;;-1:-1:-1;2042:5212:1;;4922:52;;:::i;:::-;2042:5212;;4797:197;:::o;4873:31::-;-1:-1:-1;4896:8:1;:::o;2575:307:0:-;1899:1;2702:7;2042:5212:1;2702:18:0;2698:86;;1899:1;2702:7;2042:5212:1;2575:307:0:o;2698:86::-;2042:5212:1;;-1:-1:-1;;;2743:30:0;;;;","linkReferences":{},"immutableReferences":{"105":[{"start":243,"length":32},{"start":681,"length":32},{"start":1177,"length":32},{"start":1415,"length":32},{"start":1885,"length":32},{"start":2332,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"claimableFor(address)","signatureHash4":"0xee8ad528","signatureHash32":"0xee8ad52811caf45f66c102e32be58e7e5f87bf8a3abccdb0dec7babd1b56114c"},{"signature":"claimable(uint256)","signatureHash4":"0xd1d58b25","signatureHash32":"0xd1d58b2592c9120b9afb9110cb45f01075d34ac21a7eece5700f12af5f0977ed"},{"signature":"claimAll()","signatureHash4":"0xd1058e59","signatureHash32":"0xd1058e595676d7352366be8c4f41ab994f64956f2ee4956160e25b6db85521dd"},{"signature":"claimedPerShare(uint256)","signatureHash4":"0x835cc228","signatureHash32":"0x835cc2283cd522a355dbf53b8c59001ed4e117e3bd2490ccffdead05e116ea8b"},{"signature":"claim(uint256[])","signatureHash4":"0x6ba4c138","signatureHash32":"0x6ba4c138febca78066701279f666057cf6b609e6ac3cb57b50d4cee559e688b4"},{"signature":"deposit()","signatureHash4":"0xd0e30db0","signatureHash32":"0xd0e30db03f2e24c6531d8ae2f6c09d8e7a6ad7f7e87a81cb75dfda61c9d83286"},{"signature":"dividendsPerShare()","signatureHash4":"0xe2d2e219","signatureHash32":"0xe2d2e219c74202c6e47b133d9be8a46565acefb33c065289d48b7ec64a859640"},{"signature":"isShare(uint256)","signatureHash4":"0x0c1d138b","signatureHash32":"0x0c1d138b71c2c9076800f5b0c3b0cb7a1ab9a606c47ad78fb496e639aa947ea2"},{"signature":"magnifiedDividendPerShare()","signatureHash4":"0x3a7960e0","signatureHash32":"0x3a7960e06a45a80d7dbffcc575fc84c37106deff1b50d504766b954309d76c39"},{"signature":"MAGNITUDE()","signatureHash4":"0x6d3036a7","signatureHash32":"0x6d3036a7c16d8ef5cd6bfcba13ddbc2154d2f96368c53c871a5e8cfeb73e2c45"},{"signature":"nft()","signatureHash4":"0x47ccca02","signatureHash32":"0x47ccca0201ed22f779508456c61f73397d88b6577f89f05d9bdd674c21209b55"},{"signature":"notifyMint(uint256)","signatureHash4":"0xcfb636f0","signatureHash32":"0xcfb636f01ad2e2116030960db814903541b8a681c090fcc34d675520bd8d7af6"},{"signature":"poolBalance()","signatureHash4":"0x96365d44","signatureHash32":"0x96365d444e6fd69e4b624133e603deb768d9c40e06f964d83cce3fa22ceb6b05"},{"signature":"startingPerShare(uint256)","signatureHash4":"0xcf70f471","signatureHash32":"0xcf70f471fc9b22e74786e4399ada0040d7217c5ea9983b70e3376602be996aa5"},{"signature":"totalShares()","signatureHash4":"0x3a98ef39","signatureHash32":"0x3a98ef39d75a0463a589a77e7570097b7e407deab0b5678402f964703022acc1"}],"event":[{"signature":"Claimed(address,uint256)","signatureHash4":"0xd8138f8a","signatureHash32":"0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a"},{"signature":"Deposited(uint256,uint256)","signatureHash4":"0x06da3309","signatureHash32":"0x06da3309189fa49284f335d2c2bcb4cb0b8ad2a59ad92a9bdebeeb8f1ceba511"},{"signature":"ShareMinted(uint256,uint256)","signatureHash4":"0x917c825a","signatureHash32":"0x917c825a00b397a100fbe64a061af21784b0dc7a5a025eca88c4f8dee16616e7"}],"error":[{"signature":"ReentrancyGuardReentrantCall()","signatureHash4":"0x3ee5aeb5","signatureHash32":"0x3ee5aeb571de7fc460830b4d0017439a1ca56fb0bc39062227ade4fe4a24c1ca"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0x45715164eB24787e847ce2c25798af23053F04B9"}