aitbc
816e258d4c
Development Artifact Cleanup: ✅ BROTHER_NODE REORGANIZATION: Moved development test node to appropriate location - dev/test-nodes/brother_node/: Moved from root directory for better organization - Contains development configuration, test logs, and test chain data - No impact on production systems - purely development/testing artifact ✅ DEVELOPMENT ARTIFACTS IDENTIFIED: - Chain ID: aitbc-brother-chain (test/development chain) - Ports: 8010 (P2P) and 8011 (RPC) - different from production - Environment: .env file with test configuration - Logs: rpc.log and node.log from development testing session (March 15, 2026) ✅ ROOT DIRECTORY CLEANUP: Removed development clutter from production directory - brother_node/ moved to dev/test-nodes/brother_node/ - Root directory now contains only production-ready components - Development artifacts properly organized in dev/ subdirectory DIRECTORY STRUCTURE IMPROVEMENT: 📁 dev/test-nodes/: Development and testing node configurations 🏗️ Root Directory: Clean production structure with only essential components 🧪 Development Isolation: Test environments separated from production BENEFITS: ✅ Clean Production Directory: No development artifacts in root ✅ Better Organization: Development nodes grouped in dev/ subdirectory ✅ Clear Separation: Production vs development environments clearly distinguished ✅ Maintainability: Easier to identify and manage development components RESULT: Successfully moved brother_node development artifact to dev/test-nodes/ subdirectory, cleaning up the root directory while preserving development testing environment for future use.
88 lines
3.3 KiB
Solidity
Executable File
88 lines
3.3 KiB
Solidity
Executable File
// SPDX-License-Identifier: MIT
|
|
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)
|
|
|
|
pragma solidity ^0.8.20;
|
|
|
|
/**
|
|
* @dev Contract module that helps prevent reentrant calls to a function.
|
|
*
|
|
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
|
|
* available, which can be applied to functions to make sure there are no nested
|
|
* (reentrant) calls to them.
|
|
*
|
|
* Note that because there is a single `nonReentrant` guard, functions marked as
|
|
* `nonReentrant` may not call one another. This can be worked around by making
|
|
* those functions `private`, and then adding `external` `nonReentrant` entry
|
|
* points to them.
|
|
*
|
|
* TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
|
|
* consider using {ReentrancyGuardTransient} instead.
|
|
*
|
|
* TIP: If you would like to learn more about reentrancy and alternative ways
|
|
* to protect against it, check out our blog post
|
|
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
|
|
*/
|
|
abstract contract ReentrancyGuard {
|
|
// Booleans are more expensive than uint256 or any type that takes up a full
|
|
// word because each write operation emits an extra SLOAD to first read the
|
|
// slot's contents, replace the bits taken up by the boolean, and then write
|
|
// back. This is the compiler's defense against contract upgrades and
|
|
// pointer aliasing, and it cannot be disabled.
|
|
|
|
// The values being non-zero value makes deployment a bit more expensive,
|
|
// but in exchange the refund on every call to nonReentrant will be lower in
|
|
// amount. Since refunds are capped to a percentage of the total
|
|
// transaction's gas, it is best to keep them low in cases like this one, to
|
|
// increase the likelihood of the full refund coming into effect.
|
|
uint256 private constant NOT_ENTERED = 1;
|
|
uint256 private constant ENTERED = 2;
|
|
|
|
uint256 private _status;
|
|
|
|
/**
|
|
* @dev Unauthorized reentrant call.
|
|
*/
|
|
error ReentrancyGuardReentrantCall();
|
|
|
|
constructor() {
|
|
_status = NOT_ENTERED;
|
|
}
|
|
|
|
/**
|
|
* @dev Prevents a contract from calling itself, directly or indirectly.
|
|
* Calling a `nonReentrant` function from another `nonReentrant`
|
|
* function is not supported. It is possible to prevent this from happening
|
|
* by making the `nonReentrant` function external, and making it call a
|
|
* `private` function that does the actual work.
|
|
*/
|
|
modifier nonReentrant() {
|
|
_nonReentrantBefore();
|
|
_;
|
|
_nonReentrantAfter();
|
|
}
|
|
|
|
function _nonReentrantBefore() private {
|
|
// On the first call to nonReentrant, _status will be NOT_ENTERED
|
|
if (_status == ENTERED) {
|
|
revert ReentrancyGuardReentrantCall();
|
|
}
|
|
|
|
// Any calls to nonReentrant after this point will fail
|
|
_status = ENTERED;
|
|
}
|
|
|
|
function _nonReentrantAfter() private {
|
|
// By storing the original value once again, a refund is triggered (see
|
|
// https://eips.ethereum.org/EIPS/eip-2200)
|
|
_status = NOT_ENTERED;
|
|
}
|
|
|
|
/**
|
|
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
|
|
* `nonReentrant` function in the call stack.
|
|
*/
|
|
function _reentrancyGuardEntered() internal view returns (bool) {
|
|
return _status == ENTERED;
|
|
}
|
|
}
|