+=======
+# budget2
+>>>>>>> Incoming
+
+<<<<<<< HEAD
DAOBox - Budget is an Aragon OSx Plugin that allows the execution of payments bypassing the need for regular voting.
+=======
+Note: Please ensure you have installed nodejs
+
+>>>>>>> Incoming
+<<<<<<< HEAD
+=======
+To preview and run the project on your device:
+>>>>>>> Incoming
+
+<<<<<<< HEAD
@@ -230,3 +246,38 @@ constraints of this system, this is a non-issue:
## License
This project is licensed under AGPL-3.0-or-later
+
+---
+
+```
+[submodule "lib/forge-std"]
+ branch = "v1"
+ path = "lib/forge-std"
+ url = "https://github.com/foundry-rs/forge-std"
+[submodule "lib/prb-test"]
+ branch = "release-v0"
+ path = "lib/prb-test"
+ url = "https://github.com/PaulRBerg/prb-test"
+[submodule "lib/openzeppelin-contracts"]
+ path = lib/openzeppelin-contracts
+ url = https://github.com/OpenZeppelin/openzeppelin-contracts
+[submodule "lib/osx"]
+ path = lib/osx
+ url = https://github.com/aragon/osx
+[submodule "lib/openzeppelin-contracts-upgradeable"]
+ branch = "release-v4.9"
+ path = lib/openzeppelin-contracts-upgradeable
+ url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable
+[submodule "lib/ens-contracts"]
+ path = lib/ens-contracts
+ url = https://github.com/ensdomains/ens-contracts
+[submodule "lib/BokkyPooBahsDateTimeLibrary"]
+ path = lib/BokkyPooBahsDateTimeLibrary
+ url = https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
+```
+=======
+1. Open project folder in Visual Studio Code
+2. In the terminal, run `npm install`
+3. Run `npm start` to view project in browser
+
+>>>>>>> Incoming
diff --git a/active_contracts.json b/active_contracts.json
new file mode 100644
index 0000000..61c7e20
--- /dev/null
+++ b/active_contracts.json
@@ -0,0 +1,9 @@
+{
+ "ens-domain": "budget.plugin.dao.eth",
+ "goerli": {
+ "BudgetSetup": "0x636Dc42B54029702ee5bDd39059bF8f75696B1C9",
+ "BudgetRepo": "0x9b72Af17B8aE55AE2F3C06E46A44D9bEaFb10801",
+ "dao": "0xce780fea1c950a29769b4f10817a9c51154d12af",
+ "budget": "0xfea7C89Ae8168f0f0FB9bA053b79C02819eC8C91"
+ }
+}
\ No newline at end of file
diff --git a/lib/forge-std b/lib/forge-std
deleted file mode 160000
index e8a047e..0000000
--- a/lib/forge-std
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e8a047e3f40f13fa37af6fe14e6e06283d9a060e
diff --git a/lib/openzeppelin-contracts b/lib/openzeppelin-contracts
deleted file mode 160000
index 0457042..0000000
--- a/lib/openzeppelin-contracts
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 0457042d93d9dfd760dbaa06a4d2f1216fdbe297
diff --git a/lib/openzeppelin-contracts-upgradeable b/lib/openzeppelin-contracts-upgradeable
deleted file mode 160000
index 12ad9ea..0000000
--- a/lib/openzeppelin-contracts-upgradeable
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 12ad9ea7c8e8e78f6eba9ad71ad156645d3c5b4c
diff --git a/lib/osx b/lib/osx
deleted file mode 160000
index 1bf1798..0000000
--- a/lib/osx
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 1bf17984d1a1b569c3c4b1d86026d87f74f81402
diff --git a/lib/prb-test b/lib/prb-test
deleted file mode 160000
index 1e9ead2..0000000
--- a/lib/prb-test
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 1e9ead2f7bfaedda3038081c16484b0d7d0b2712
diff --git a/package.json b/package.json
index 5bf6c96..49b5322 100644
--- a/package.json
+++ b/package.json
@@ -1,39 +1,62 @@
{
- "name": "@daobox/budget",
- "description": "",
+<<<<<<< HEAD
+ "name": "budget-monorepo",
"version": "1.0.0",
- "author": {
- "name": "DAObox",
- "url": "https://github.com/DAObox"
+ "description": "",
+ "main": "index.js",
+=======
+ "name": "budget2",
+ "version": "0.1.0",
+ "private": true,
+ "dependencies": {
+ "@testing-library/jest-dom": "^5.16.5",
+ "@testing-library/react": "^13.4.0",
+ "@testing-library/user-event": "^13.5.0",
+ "@types/jest": "^29.5.0",
+ "@types/node": "^16.11.14",
+ "@types/react": "^18.0.28",
+ "@types/react-dom": "^18.0.11",
+ "react": "^18.2.0",
+ "react-dom": "^18.2.0",
+ "react-scripts": "5.0.1",
+ "web-vitals": "^2.1.4",
+ "typescript": "^4.5.4",
+ "react-router-dom": "^6.2.1"
},
"devDependencies": {
- "prettier": "^3.0.0"
+ "autoprefixer": "^10.4.8",
+ "postcss": "^8.4.16",
+ "tailwindcss": "^3.1.8"
},
- "keywords": [
- "blockchain",
- "ethereum",
- "forge",
- "foundry",
- "smart-contracts",
- "solidity",
- "aragon",
- "osx",
- "dao",
- "daobox"
- ],
- "private": true,
+
+>>>>>>> Incoming
"scripts": {
- "clean": "rm -rf cache out",
- "build": "forge build",
- "lint": "pnpm lint:sol && pnpm prettier:check",
- "lint:sol": "forge fmt --check && pnpm solhint {script,src,test}/**/*.sol",
- "prettier:check": "prettier --check **/*.{json,md,yml} --ignore-path=.prettierignore",
- "prettier:write": "prettier --write **/*.{json,md,yml} --ignore-path=.prettierignore",
- "test": "forge test -vvv",
- "test:coverage": "forge coverage",
- "test:coverage:report": "forge coverage --report lcov && genhtml lcov.info --branch-coverage --output-dir coverage"
+<<<<<<< HEAD
+ "test": "echo \"Error: no test specified\" && exit 1"
+=======
+ "start": "react-scripts start",
+ "build": "react-scripts build",
+ "test": "react-scripts test",
+ "eject": "react-scripts eject"
+
+>>>>>>> Incoming
},
- "dependencies": {
- "solhint": "^3.6.2"
+<<<<<<< HEAD
+ "keywords": [],
+ "author": "pythonpete32",
+ "license": "ISC"
+=======
+ "eslintConfig": {
+ "root": true
+ },
+ "browserslist": {
+ "production": [">0.2%", "not dead", "not op_mini all"],
+ "development": [
+ "last 1 chrome version",
+ "last 1 firefox version",
+ "last 1 safari version"
+ ]
}
+
+>>>>>>> Incoming
}
diff --git a/packages/.DS_Store b/packages/.DS_Store
new file mode 100644
index 0000000..44602d9
Binary files /dev/null and b/packages/.DS_Store differ
diff --git a/.env.example b/packages/contracts/.env.example
similarity index 100%
rename from .env.example
rename to packages/contracts/.env.example
diff --git a/.gitattributes b/packages/contracts/.gitattributes
similarity index 100%
rename from .gitattributes
rename to packages/contracts/.gitattributes
diff --git a/packages/contracts/.gitignore b/packages/contracts/.gitignore
new file mode 100644
index 0000000..769b47c
--- /dev/null
+++ b/packages/contracts/.gitignore
@@ -0,0 +1,18 @@
+# directories
+cache
+coverage
+node_modules
+out
+
+# files
+*.env
+*.log
+.DS_Store
+.pnp.*
+lcov.info
+yarn.lock
+
+# broadcasts
+!broadcast
+broadcast/*
+broadcast/*/31337/
diff --git a/.prettierignore b/packages/contracts/.prettierignore
similarity index 100%
rename from .prettierignore
rename to packages/contracts/.prettierignore
diff --git a/.prettierrc.yml b/packages/contracts/.prettierrc.yml
similarity index 100%
rename from .prettierrc.yml
rename to packages/contracts/.prettierrc.yml
diff --git a/.solhint.json b/packages/contracts/.solhint.json
similarity index 100%
rename from .solhint.json
rename to packages/contracts/.solhint.json
diff --git a/foundry.toml b/packages/contracts/foundry.toml
similarity index 100%
rename from foundry.toml
rename to packages/contracts/foundry.toml
diff --git a/lib/BokkyPooBahsDateTimeLibrary b/packages/contracts/lib/BokkyPooBahsDateTimeLibrary
similarity index 100%
rename from lib/BokkyPooBahsDateTimeLibrary
rename to packages/contracts/lib/BokkyPooBahsDateTimeLibrary
diff --git a/lib/ens-contracts b/packages/contracts/lib/ens-contracts
similarity index 100%
rename from lib/ens-contracts
rename to packages/contracts/lib/ens-contracts
diff --git a/packages/contracts/lib/forge-std b/packages/contracts/lib/forge-std
new file mode 160000
index 0000000..f73c73d
--- /dev/null
+++ b/packages/contracts/lib/forge-std
@@ -0,0 +1 @@
+Subproject commit f73c73d2018eb6a111f35e4dae7b4f27401e9421
diff --git a/packages/contracts/lib/openzeppelin-contracts b/packages/contracts/lib/openzeppelin-contracts
new file mode 160000
index 0000000..fd81a96
--- /dev/null
+++ b/packages/contracts/lib/openzeppelin-contracts
@@ -0,0 +1 @@
+Subproject commit fd81a96f01cc42ef1c9a5399364968d0e07e9e90
diff --git a/packages/contracts/lib/openzeppelin-contracts-upgradeable b/packages/contracts/lib/openzeppelin-contracts-upgradeable
new file mode 160000
index 0000000..3d4c0d5
--- /dev/null
+++ b/packages/contracts/lib/openzeppelin-contracts-upgradeable
@@ -0,0 +1 @@
+Subproject commit 3d4c0d5741b131c231e558d7a6213392ab3672a5
diff --git a/packages/contracts/lib/osx b/packages/contracts/lib/osx
new file mode 160000
index 0000000..c2be413
--- /dev/null
+++ b/packages/contracts/lib/osx
@@ -0,0 +1 @@
+Subproject commit c2be413a998c2995f4ed36ca648a5fd9b4284e77
diff --git a/packages/contracts/lib/prb-test b/packages/contracts/lib/prb-test
new file mode 160000
index 0000000..2ece875
--- /dev/null
+++ b/packages/contracts/lib/prb-test
@@ -0,0 +1 @@
+Subproject commit 2ece8755d9afe7d66440ef9ca19b8a9dab40164b
diff --git a/packages/contracts/out.sol b/packages/contracts/out.sol
new file mode 100644
index 0000000..eb5ffd5
--- /dev/null
+++ b/packages/contracts/out.sol
@@ -0,0 +1,2716 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.17;
+
+// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)
+
+// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
+
+/**
+ * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
+ * proxy whose upgrades are fully controlled by the current implementation.
+ */
+interface IERC1822ProxiableUpgradeable {
+ /**
+ * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
+ * address.
+ *
+ * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
+ * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
+ * function revert if invoked through a proxy.
+ */
+ function proxiableUUID() external view returns (bytes32);
+}
+
+// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)
+
+// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
+
+/**
+ * @dev This is the interface that {BeaconProxy} expects of its beacon.
+ */
+interface IBeaconUpgradeable {
+ /**
+ * @dev Must return an address that can be used as a delegate call target.
+ *
+ * {BeaconProxy} will check that this address is a contract.
+ */
+ function implementation() external view returns (address);
+}
+
+// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)
+
+/**
+ * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
+ *
+ * _Available since v4.8.3._
+ */
+interface IERC1967Upgradeable {
+ /**
+ * @dev Emitted when the implementation is upgraded.
+ */
+ event Upgraded(address indexed implementation);
+
+ /**
+ * @dev Emitted when the admin account has changed.
+ */
+ event AdminChanged(address previousAdmin, address newAdmin);
+
+ /**
+ * @dev Emitted when the beacon is changed.
+ */
+ event BeaconUpgraded(address indexed beacon);
+}
+
+// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
+
+/**
+ * @dev Collection of functions related to the address type
+ */
+library AddressUpgradeable {
+ /**
+ * @dev Returns true if `account` is a contract.
+ *
+ * [IMPORTANT]
+ * ====
+ * It is unsafe to assume that an address for which this function returns
+ * false is an externally-owned account (EOA) and not a contract.
+ *
+ * Among others, `isContract` will return false for the following
+ * types of addresses:
+ *
+ * - an externally-owned account
+ * - a contract in construction
+ * - an address where a contract will be created
+ * - an address where a contract lived, but was destroyed
+ *
+ * Furthermore, `isContract` will also return true if the target contract within
+ * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
+ * which only has an effect at the end of a transaction.
+ * ====
+ *
+ * [IMPORTANT]
+ * ====
+ * You shouldn't rely on `isContract` to protect against flash loan attacks!
+ *
+ * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
+ * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
+ * constructor.
+ * ====
+ */
+ function isContract(address account) internal view returns (bool) {
+ // This method relies on extcodesize/address.code.length, which returns 0
+ // for contracts in construction, since the code is only stored at the end
+ // of the constructor execution.
+
+ return account.code.length > 0;
+ }
+
+ /**
+ * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
+ * `recipient`, forwarding all available gas and reverting on errors.
+ *
+ * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
+ * of certain opcodes, possibly making contracts go over the 2300 gas limit
+ * imposed by `transfer`, making them unable to receive funds via
+ * `transfer`. {sendValue} removes this limitation.
+ *
+ * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
+ *
+ * IMPORTANT: because control is transferred to `recipient`, care must be
+ * taken to not create reentrancy vulnerabilities. Consider using
+ * {ReentrancyGuard} or the
+ * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
+ */
+ function sendValue(address payable recipient, uint256 amount) internal {
+ require(address(this).balance >= amount, "Address: insufficient balance");
+
+ (bool success, ) = recipient.call{value: amount}("");
+ require(success, "Address: unable to send value, recipient may have reverted");
+ }
+
+ /**
+ * @dev Performs a Solidity function call using a low level `call`. A
+ * plain `call` is an unsafe replacement for a function call: use this
+ * function instead.
+ *
+ * If `target` reverts with a revert reason, it is bubbled up by this
+ * function (like regular Solidity function calls).
+ *
+ * Returns the raw returned data. To convert to the expected return value,
+ * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
+ *
+ * Requirements:
+ *
+ * - `target` must be a contract.
+ * - calling `target` with `data` must not revert.
+ *
+ * _Available since v3.1._
+ */
+ function functionCall(address target, bytes memory data) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, 0, "Address: low-level call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
+ * `errorMessage` as a fallback revert reason when `target` reverts.
+ *
+ * _Available since v3.1._
+ */
+ function functionCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, 0, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but also transferring `value` wei to `target`.
+ *
+ * Requirements:
+ *
+ * - the calling contract must have an ETH balance of at least `value`.
+ * - the called Solidity function must be `payable`.
+ *
+ * _Available since v3.1._
+ */
+ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
+ * with `errorMessage` as a fallback revert reason when `target` reverts.
+ *
+ * _Available since v3.1._
+ */
+ function functionCallWithValue(
+ address target,
+ bytes memory data,
+ uint256 value,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ require(address(this).balance >= value, "Address: insufficient balance for call");
+ (bool success, bytes memory returndata) = target.call{value: value}(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but performing a static call.
+ *
+ * _Available since v3.3._
+ */
+ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
+ return functionStaticCall(target, data, "Address: low-level static call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
+ * but performing a static call.
+ *
+ * _Available since v3.3._
+ */
+ function functionStaticCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal view returns (bytes memory) {
+ (bool success, bytes memory returndata) = target.staticcall(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but performing a delegate call.
+ *
+ * _Available since v3.4._
+ */
+ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
+ return functionDelegateCall(target, data, "Address: low-level delegate call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
+ * but performing a delegate call.
+ *
+ * _Available since v3.4._
+ */
+ function functionDelegateCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ (bool success, bytes memory returndata) = target.delegatecall(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
+ * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
+ *
+ * _Available since v4.8._
+ */
+ function verifyCallResultFromTarget(
+ address target,
+ bool success,
+ bytes memory returndata,
+ string memory errorMessage
+ ) internal view returns (bytes memory) {
+ if (success) {
+ if (returndata.length == 0) {
+ // only check isContract if the call was successful and the return data is empty
+ // otherwise we already know that it was a contract
+ require(isContract(target), "Address: call to non-contract");
+ }
+ return returndata;
+ } else {
+ _revert(returndata, errorMessage);
+ }
+ }
+
+ /**
+ * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
+ * revert reason or using the provided one.
+ *
+ * _Available since v4.3._
+ */
+ function verifyCallResult(
+ bool success,
+ bytes memory returndata,
+ string memory errorMessage
+ ) internal pure returns (bytes memory) {
+ if (success) {
+ return returndata;
+ } else {
+ _revert(returndata, errorMessage);
+ }
+ }
+
+ function _revert(bytes memory returndata, string memory errorMessage) private pure {
+ // Look for revert reason and bubble it up if present
+ if (returndata.length > 0) {
+ // The easiest way to bubble the revert reason is using memory via assembly
+ /// @solidity memory-safe-assembly
+ assembly {
+ let returndata_size := mload(returndata)
+ revert(add(32, returndata), returndata_size)
+ }
+ } else {
+ revert(errorMessage);
+ }
+ }
+}
+
+// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
+// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
+
+/**
+ * @dev Library for reading and writing primitive types to specific storage slots.
+ *
+ * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
+ * This library helps with reading and writing to such slots without the need for inline assembly.
+ *
+ * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
+ *
+ * Example usage to set ERC1967 implementation slot:
+ * ```solidity
+ * contract ERC1967 {
+ * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+ *
+ * function _getImplementation() internal view returns (address) {
+ * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
+ * }
+ *
+ * function _setImplementation(address newImplementation) internal {
+ * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
+ * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
+ * }
+ * }
+ * ```
+ *
+ * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
+ * _Available since v4.9 for `string`, `bytes`._
+ */
+library StorageSlotUpgradeable {
+ struct AddressSlot {
+ address value;
+ }
+
+ struct BooleanSlot {
+ bool value;
+ }
+
+ struct Bytes32Slot {
+ bytes32 value;
+ }
+
+ struct Uint256Slot {
+ uint256 value;
+ }
+
+ struct StringSlot {
+ string value;
+ }
+
+ struct BytesSlot {
+ bytes value;
+ }
+
+ /**
+ * @dev Returns an `AddressSlot` with member `value` located at `slot`.
+ */
+ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
+ /// @solidity memory-safe-assembly
+ assembly {
+ r.slot := slot
+ }
+ }
+
+ /**
+ * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
+ */
+ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
+ /// @solidity memory-safe-assembly
+ assembly {
+ r.slot := slot
+ }
+ }
+
+ /**
+ * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
+ */
+ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
+ /// @solidity memory-safe-assembly
+ assembly {
+ r.slot := slot
+ }
+ }
+
+ /**
+ * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
+ */
+ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
+ /// @solidity memory-safe-assembly
+ assembly {
+ r.slot := slot
+ }
+ }
+
+ /**
+ * @dev Returns an `StringSlot` with member `value` located at `slot`.
+ */
+ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
+ /// @solidity memory-safe-assembly
+ assembly {
+ r.slot := slot
+ }
+ }
+
+ /**
+ * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
+ */
+ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
+ /// @solidity memory-safe-assembly
+ assembly {
+ r.slot := store.slot
+ }
+ }
+
+ /**
+ * @dev Returns an `BytesSlot` with member `value` located at `slot`.
+ */
+ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
+ /// @solidity memory-safe-assembly
+ assembly {
+ r.slot := slot
+ }
+ }
+
+ /**
+ * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
+ */
+ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
+ /// @solidity memory-safe-assembly
+ assembly {
+ r.slot := store.slot
+ }
+ }
+}
+
+// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
+
+/**
+ * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
+ * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
+ * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
+ * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
+ *
+ * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
+ * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
+ * case an upgrade adds a module that needs to be initialized.
+ *
+ * For example:
+ *
+ * [.hljs-theme-light.nopadding]
+ * ```solidity
+ * contract MyToken is ERC20Upgradeable {
+ * function initialize() initializer public {
+ * __ERC20_init("MyToken", "MTK");
+ * }
+ * }
+ *
+ * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
+ * function initializeV2() reinitializer(2) public {
+ * __ERC20Permit_init("MyToken");
+ * }
+ * }
+ * ```
+ *
+ * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
+ * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
+ *
+ * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
+ * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
+ *
+ * [CAUTION]
+ * ====
+ * Avoid leaving a contract uninitialized.
+ *
+ * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
+ * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
+ * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
+ *
+ * [.hljs-theme-light.nopadding]
+ * ```
+ * /// @custom:oz-upgrades-unsafe-allow constructor
+ * constructor() {
+ * _disableInitializers();
+ * }
+ * ```
+ * ====
+ */
+abstract contract Initializable {
+ /**
+ * @dev Indicates that the contract has been initialized.
+ * @custom:oz-retyped-from bool
+ */
+ uint8 private _initialized;
+
+ /**
+ * @dev Indicates that the contract is in the process of being initialized.
+ */
+ bool private _initializing;
+
+ /**
+ * @dev Triggered when the contract has been initialized or reinitialized.
+ */
+ event Initialized(uint8 version);
+
+ /**
+ * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
+ * `onlyInitializing` functions can be used to initialize parent contracts.
+ *
+ * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
+ * constructor.
+ *
+ * Emits an {Initialized} event.
+ */
+ modifier initializer() {
+ bool isTopLevelCall = !_initializing;
+ require(
+ (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
+ "Initializable: contract is already initialized"
+ );
+ _initialized = 1;
+ if (isTopLevelCall) {
+ _initializing = true;
+ }
+ _;
+ if (isTopLevelCall) {
+ _initializing = false;
+ emit Initialized(1);
+ }
+ }
+
+ /**
+ * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
+ * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
+ * used to initialize parent contracts.
+ *
+ * A reinitializer may be used after the original initialization step. This is essential to configure modules that
+ * are added through upgrades and that require initialization.
+ *
+ * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
+ * cannot be nested. If one is invoked in the context of another, execution will revert.
+ *
+ * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
+ * a contract, executing them in the right order is up to the developer or operator.
+ *
+ * WARNING: setting the version to 255 will prevent any future reinitialization.
+ *
+ * Emits an {Initialized} event.
+ */
+ modifier reinitializer(uint8 version) {
+ require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
+ _initialized = version;
+ _initializing = true;
+ _;
+ _initializing = false;
+ emit Initialized(version);
+ }
+
+ /**
+ * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
+ * {initializer} and {reinitializer} modifiers, directly or indirectly.
+ */
+ modifier onlyInitializing() {
+ require(_initializing, "Initializable: contract is not initializing");
+ _;
+ }
+
+ /**
+ * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
+ * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
+ * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
+ * through proxies.
+ *
+ * Emits an {Initialized} event the first time it is successfully executed.
+ */
+ function _disableInitializers() internal virtual {
+ require(!_initializing, "Initializable: contract is initializing");
+ if (_initialized != type(uint8).max) {
+ _initialized = type(uint8).max;
+ emit Initialized(type(uint8).max);
+ }
+ }
+
+ /**
+ * @dev Returns the highest version that has been initialized. See {reinitializer}.
+ */
+ function _getInitializedVersion() internal view returns (uint8) {
+ return _initialized;
+ }
+
+ /**
+ * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
+ */
+ function _isInitializing() internal view returns (bool) {
+ return _initializing;
+ }
+}
+
+/**
+ * @dev This abstract contract provides getters and event emitting update functions for
+ * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
+ *
+ * _Available since v4.1._
+ */
+abstract contract ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
+ function __ERC1967Upgrade_init() internal onlyInitializing {
+ }
+
+ function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
+ }
+ // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
+ bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
+
+ /**
+ * @dev Storage slot with the address of the current implementation.
+ * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
+ * validated in the constructor.
+ */
+ bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+
+ /**
+ * @dev Returns the current implementation address.
+ */
+ function _getImplementation() internal view returns (address) {
+ return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
+ }
+
+ /**
+ * @dev Stores a new address in the EIP1967 implementation slot.
+ */
+ function _setImplementation(address newImplementation) private {
+ require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
+ StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
+ }
+
+ /**
+ * @dev Perform implementation upgrade
+ *
+ * Emits an {Upgraded} event.
+ */
+ function _upgradeTo(address newImplementation) internal {
+ _setImplementation(newImplementation);
+ emit Upgraded(newImplementation);
+ }
+
+ /**
+ * @dev Perform implementation upgrade with additional setup call.
+ *
+ * Emits an {Upgraded} event.
+ */
+ function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
+ _upgradeTo(newImplementation);
+ if (data.length > 0 || forceCall) {
+ AddressUpgradeable.functionDelegateCall(newImplementation, data);
+ }
+ }
+
+ /**
+ * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
+ *
+ * Emits an {Upgraded} event.
+ */
+ function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
+ // Upgrades from old implementations will perform a rollback test. This test requires the new
+ // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
+ // this special case will break upgrade paths from old UUPS implementation to new ones.
+ if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
+ _setImplementation(newImplementation);
+ } else {
+ try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
+ require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
+ } catch {
+ revert("ERC1967Upgrade: new implementation is not UUPS");
+ }
+ _upgradeToAndCall(newImplementation, data, forceCall);
+ }
+ }
+
+ /**
+ * @dev Storage slot with the admin of the contract.
+ * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
+ * validated in the constructor.
+ */
+ bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
+
+ /**
+ * @dev Returns the current admin.
+ */
+ function _getAdmin() internal view returns (address) {
+ return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
+ }
+
+ /**
+ * @dev Stores a new address in the EIP1967 admin slot.
+ */
+ function _setAdmin(address newAdmin) private {
+ require(newAdmin != address(0), "ERC1967: new admin is the zero address");
+ StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
+ }
+
+ /**
+ * @dev Changes the admin of the proxy.
+ *
+ * Emits an {AdminChanged} event.
+ */
+ function _changeAdmin(address newAdmin) internal {
+ emit AdminChanged(_getAdmin(), newAdmin);
+ _setAdmin(newAdmin);
+ }
+
+ /**
+ * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
+ * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
+ */
+ bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
+
+ /**
+ * @dev Returns the current beacon.
+ */
+ function _getBeacon() internal view returns (address) {
+ return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
+ }
+
+ /**
+ * @dev Stores a new beacon in the EIP1967 beacon slot.
+ */
+ function _setBeacon(address newBeacon) private {
+ require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
+ require(
+ AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
+ "ERC1967: beacon implementation is not a contract"
+ );
+ StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
+ }
+
+ /**
+ * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
+ * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
+ *
+ * Emits a {BeaconUpgraded} event.
+ */
+ function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
+ _setBeacon(newBeacon);
+ emit BeaconUpgraded(newBeacon);
+ if (data.length > 0 || forceCall) {
+ AddressUpgradeable.functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
+ }
+ }
+
+ /**
+ * @dev This empty reserved space is put in place to allow future versions to add new
+ * variables without shifting down storage in the inheritance chain.
+ * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+ */
+ uint256[50] private __gap;
+}
+
+/**
+ * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
+ * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
+ *
+ * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
+ * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
+ * `UUPSUpgradeable` with a custom implementation of upgrades.
+ *
+ * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
+ *
+ * _Available since v4.1._
+ */
+abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
+ function __UUPSUpgradeable_init() internal onlyInitializing {
+ }
+
+ function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
+ }
+ /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
+ address private immutable __self = address(this);
+
+ /**
+ * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
+ * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
+ * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
+ * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
+ * fail.
+ */
+ modifier onlyProxy() {
+ require(address(this) != __self, "Function must be called through delegatecall");
+ require(_getImplementation() == __self, "Function must be called through active proxy");
+ _;
+ }
+
+ /**
+ * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
+ * callable on the implementing contract but not through proxies.
+ */
+ modifier notDelegated() {
+ require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
+ _;
+ }
+
+ /**
+ * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
+ * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
+ *
+ * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
+ * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
+ * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
+ */
+ function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
+ return _IMPLEMENTATION_SLOT;
+ }
+
+ /**
+ * @dev Upgrade the implementation of the proxy to `newImplementation`.
+ *
+ * Calls {_authorizeUpgrade}.
+ *
+ * Emits an {Upgraded} event.
+ *
+ * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
+ */
+ function upgradeTo(address newImplementation) public virtual onlyProxy {
+ _authorizeUpgrade(newImplementation);
+ _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
+ }
+
+ /**
+ * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
+ * encoded in `data`.
+ *
+ * Calls {_authorizeUpgrade}.
+ *
+ * Emits an {Upgraded} event.
+ *
+ * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
+ */
+ function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
+ _authorizeUpgrade(newImplementation);
+ _upgradeToAndCallUUPS(newImplementation, data, true);
+ }
+
+ /**
+ * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
+ * {upgradeTo} and {upgradeToAndCall}.
+ *
+ * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
+ *
+ * ```solidity
+ * function _authorizeUpgrade(address) internal override onlyOwner {}
+ * ```
+ */
+ function _authorizeUpgrade(address newImplementation) internal virtual;
+
+ /**
+ * @dev This empty reserved space is put in place to allow future versions to add new
+ * variables without shifting down storage in the inheritance chain.
+ * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+ */
+ uint256[50] private __gap;
+}
+
+// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
+
+// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
+
+/**
+ * @dev Interface of the ERC165 standard, as defined in the
+ * https://eips.ethereum.org/EIPS/eip-165[EIP].
+ *
+ * Implementers can declare support of contract interfaces, which can then be
+ * queried by others ({ERC165Checker}).
+ *
+ * For an implementation, see {ERC165}.
+ */
+interface IERC165Upgradeable {
+ /**
+ * @dev Returns true if this contract implements the interface defined by
+ * `interfaceId`. See the corresponding
+ * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
+ * to learn more about how these ids are created.
+ *
+ * This function call must use less than 30 000 gas.
+ */
+ function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
+
+/**
+ * @dev Implementation of the {IERC165} interface.
+ *
+ * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
+ * for the additional interface id that will be supported. For example:
+ *
+ * ```solidity
+ * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+ * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
+ * }
+ * ```
+ *
+ * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
+ */
+abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
+ function __ERC165_init() internal onlyInitializing {
+ }
+
+ function __ERC165_init_unchained() internal onlyInitializing {
+ }
+ /**
+ * @dev See {IERC165-supportsInterface}.
+ */
+ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+ return interfaceId == type(IERC165Upgradeable).interfaceId;
+ }
+
+ /**
+ * @dev This empty reserved space is put in place to allow future versions to add new
+ * variables without shifting down storage in the inheritance chain.
+ * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+ */
+ uint256[50] private __gap;
+}
+
+/// @title IProtocolVersion
+/// @author Aragon Association - 2022-2023
+/// @notice An interface defining the semantic Aragon OSx protocol version number.
+/// @custom:security-contact sirt@aragon.org
+interface IProtocolVersion {
+ /// @notice Returns the semantic Aragon OSx protocol version number that the implementing contract is associated with.
+ /// @return _version Returns the semantic Aragon OSx protocol version number.
+ /// @dev This version number is not to be confused with the `release` and `build` numbers found in the `Version.Tag` struct inside the `PluginRepo` contract being used to version plugin setup and associated plugin implementation contracts.
+ function protocolVersion() external view returns (uint8[3] memory _version);
+}
+
+/// @title ProtocolVersion
+/// @author Aragon Association - 2023
+/// @notice An abstract, stateless, non-upgradeable contract providing the current Aragon OSx protocol version number.
+/// @dev Do not add any new variables to this contract that would shift down storage in the inheritance chain.
+/// @custom:security-contact sirt@aragon.org
+abstract contract ProtocolVersion is IProtocolVersion {
+ // IMPORTANT: Do not add any storage variable, see the above notice.
+
+ /// @inheritdoc IProtocolVersion
+ function protocolVersion() public pure returns (uint8[3] memory) {
+ return [1, 4, 0];
+ }
+}
+
+/// @title IDAO
+/// @author Aragon Association - 2022-2023
+/// @notice The interface required for DAOs within the Aragon App DAO framework.
+/// @custom:security-contact sirt@aragon.org
+interface IDAO {
+ /// @notice The action struct to be consumed by the DAO's `execute` function resulting in an external call.
+ /// @param to The address to call.
+ /// @param value The native token value to be sent with the call.
+ /// @param data The bytes-encoded function selector and calldata for the call.
+ struct Action {
+ address to;
+ uint256 value;
+ bytes data;
+ }
+
+ /// @notice Checks if an address has permission on a contract via a permission identifier and considers if `ANY_ADDRESS` was used in the granting process.
+ /// @param _where The address of the contract.
+ /// @param _who The address of a EOA or contract to give the permissions.
+ /// @param _permissionId The permission identifier.
+ /// @param _data The optional data passed to the `PermissionCondition` registered.
+ /// @return Returns true if the address has permission, false if not.
+ function hasPermission(
+ address _where,
+ address _who,
+ bytes32 _permissionId,
+ bytes memory _data
+ ) external view returns (bool);
+
+ /// @notice Updates the DAO metadata (e.g., an IPFS hash).
+ /// @param _metadata The IPFS hash of the new metadata object.
+ function setMetadata(bytes calldata _metadata) external;
+
+ /// @notice Emitted when the DAO metadata is updated.
+ /// @param metadata The IPFS hash of the new metadata object.
+ event MetadataSet(bytes metadata);
+
+ /// @notice Executes a list of actions. If a zero allow-failure map is provided, a failing action reverts the entire execution. If a non-zero allow-failure map is provided, allowed actions can fail without the entire call being reverted.
+ /// @param _callId The ID of the call. The definition of the value of `callId` is up to the calling contract and can be used, e.g., as a nonce.
+ /// @param _actions The array of actions.
+ /// @param _allowFailureMap A bitmap allowing execution to succeed, even if individual actions might revert. If the bit at index `i` is 1, the execution succeeds even if the `i`th action reverts. A failure map value of 0 requires every action to not revert.
+ /// @return The array of results obtained from the executed actions in `bytes`.
+ /// @return The resulting failure map containing the actions have actually failed.
+ function execute(
+ bytes32 _callId,
+ Action[] memory _actions,
+ uint256 _allowFailureMap
+ ) external returns (bytes[] memory, uint256);
+
+ /// @notice Emitted when a proposal is executed.
+ /// @param actor The address of the caller.
+ /// @param callId The ID of the call.
+ /// @param actions The array of actions executed.
+ /// @param allowFailureMap The allow failure map encoding which actions are allowed to fail.
+ /// @param failureMap The failure map encoding which actions have failed.
+ /// @param execResults The array with the results of the executed actions.
+ /// @dev The value of `callId` is defined by the component/contract calling the execute function. A `Plugin` implementation can use it, for example, as a nonce.
+ event Executed(
+ address indexed actor,
+ bytes32 callId,
+ Action[] actions,
+ uint256 allowFailureMap,
+ uint256 failureMap,
+ bytes[] execResults
+ );
+
+ /// @notice Emitted when a standard callback is registered.
+ /// @param interfaceId The ID of the interface.
+ /// @param callbackSelector The selector of the callback function.
+ /// @param magicNumber The magic number to be registered for the callback function selector.
+ event StandardCallbackRegistered(
+ bytes4 interfaceId,
+ bytes4 callbackSelector,
+ bytes4 magicNumber
+ );
+
+ /// @notice Deposits (native) tokens to the DAO contract with a reference string.
+ /// @param _token The address of the token or address(0) in case of the native token.
+ /// @param _amount The amount of tokens to deposit.
+ /// @param _reference The reference describing the deposit reason.
+ function deposit(address _token, uint256 _amount, string calldata _reference) external payable;
+
+ /// @notice Emitted when a token deposit has been made to the DAO.
+ /// @param sender The address of the sender.
+ /// @param token The address of the deposited token.
+ /// @param amount The amount of tokens deposited.
+ /// @param _reference The reference describing the deposit reason.
+ event Deposited(
+ address indexed sender,
+ address indexed token,
+ uint256 amount,
+ string _reference
+ );
+
+ /// @notice Emitted when a native token deposit has been made to the DAO.
+ /// @dev This event is intended to be emitted in the `receive` function and is therefore bound by the gas limitations for `send`/`transfer` calls introduced by [ERC-2929](https://eips.ethereum.org/EIPS/eip-2929).
+ /// @param sender The address of the sender.
+ /// @param amount The amount of native tokens deposited.
+ event NativeTokenDeposited(address sender, uint256 amount);
+
+ /// @notice Setter for the trusted forwarder verifying the meta transaction.
+ /// @param _trustedForwarder The trusted forwarder address.
+ function setTrustedForwarder(address _trustedForwarder) external;
+
+ /// @notice Getter for the trusted forwarder verifying the meta transaction.
+ /// @return The trusted forwarder address.
+ function getTrustedForwarder() external view returns (address);
+
+ /// @notice Emitted when a new TrustedForwarder is set on the DAO.
+ /// @param forwarder the new forwarder address.
+ event TrustedForwarderSet(address forwarder);
+
+ /// @notice Checks whether a signature is valid for a provided hash according to [ERC-1271](https://eips.ethereum.org/EIPS/eip-1271).
+ /// @param _hash The hash of the data to be signed.
+ /// @param _signature The signature byte array associated with `_hash`.
+ /// @return Returns the `bytes4` magic value `0x1626ba7e` if the signature is valid and `0xffffffff` if not.
+ function isValidSignature(bytes32 _hash, bytes memory _signature) external returns (bytes4);
+
+ /// @notice Registers an ERC standard having a callback by registering its [ERC-165](https://eips.ethereum.org/EIPS/eip-165) interface ID and callback function signature.
+ /// @param _interfaceId The ID of the interface.
+ /// @param _callbackSelector The selector of the callback function.
+ /// @param _magicNumber The magic number to be registered for the function signature.
+ function registerStandardCallback(
+ bytes4 _interfaceId,
+ bytes4 _callbackSelector,
+ bytes4 _magicNumber
+ ) external;
+
+ /// @notice Removed function being left here to not corrupt the IDAO interface ID. Any call will revert.
+ /// @dev Introduced in v1.0.0. Removed in v1.4.0.
+ function setSignatureValidator(address) external;
+}
+
+// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
+
+/**
+ * @dev Provides information about the current execution context, including the
+ * sender of the transaction and its data. While these are generally available
+ * via msg.sender and msg.data, they should not be accessed in such a direct
+ * manner, since when dealing with meta-transactions the account sending and
+ * paying for execution may not be the actual sender (as far as an application
+ * is concerned).
+ *
+ * This contract is only required for intermediate, library-like contracts.
+ */
+abstract contract ContextUpgradeable is Initializable {
+ function __Context_init() internal onlyInitializing {
+ }
+
+ function __Context_init_unchained() internal onlyInitializing {
+ }
+ function _msgSender() internal view virtual returns (address) {
+ return msg.sender;
+ }
+
+ function _msgData() internal view virtual returns (bytes calldata) {
+ return msg.data;
+ }
+
+ /**
+ * @dev This empty reserved space is put in place to allow future versions to add new
+ * variables without shifting down storage in the inheritance chain.
+ * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+ */
+ uint256[50] private __gap;
+}
+
+/// @notice Thrown if a call is unauthorized in the associated DAO.
+/// @param dao The associated DAO.
+/// @param where The context in which the authorization reverted.
+/// @param who The address (EOA or contract) missing the permission.
+/// @param permissionId The permission identifier.
+error DaoUnauthorized(address dao, address where, address who, bytes32 permissionId);
+
+/// @notice A free function checking if a caller is granted permissions on a target contract via a permission identifier that redirects the approval to a `PermissionCondition` if this was specified in the setup.
+/// @param _where The address of the target contract for which `who` receives permission.
+/// @param _who The address (EOA or contract) owning the permission.
+/// @param _permissionId The permission identifier.
+/// @param _data The optional data passed to the `PermissionCondition` registered.
+/// @custom:security-contact sirt@aragon.org
+function _auth(
+ IDAO _dao,
+ address _where,
+ address _who,
+ bytes32 _permissionId,
+ bytes calldata _data
+) view {
+ if (!_dao.hasPermission(_where, _who, _permissionId, _data))
+ revert DaoUnauthorized({
+ dao: address(_dao),
+ where: _where,
+ who: _who,
+ permissionId: _permissionId
+ });
+}
+
+/// @title DaoAuthorizableUpgradeable
+/// @author Aragon Association - 2022-2023
+/// @notice An abstract contract providing a meta-transaction compatible modifier for upgradeable or cloneable contracts to authorize function calls through an associated DAO.
+/// @dev Make sure to call `__DaoAuthorizableUpgradeable_init` during initialization of the inheriting contract.
+/// @custom:security-contact sirt@aragon.org
+abstract contract DaoAuthorizableUpgradeable is ContextUpgradeable {
+ /// @notice The associated DAO managing the permissions of inheriting contracts.
+ IDAO private dao_;
+
+ /// @notice Initializes the contract by setting the associated DAO.
+ /// @param _dao The associated DAO address.
+ function __DaoAuthorizableUpgradeable_init(IDAO _dao) internal onlyInitializing {
+ dao_ = _dao;
+ }
+
+ /// @notice Returns the DAO contract.
+ /// @return The DAO contract.
+ function dao() public view returns (IDAO) {
+ return dao_;
+ }
+
+ /// @notice A modifier to make functions on inheriting contracts authorized. Permissions to call the function are checked through the associated DAO's permission manager.
+ /// @param _permissionId The permission identifier required to call the method this modifier is applied to.
+ modifier auth(bytes32 _permissionId) {
+ _auth(dao_, address(this), _msgSender(), _permissionId, _msgData());
+ _;
+ }
+
+ /// @notice This empty reserved space is put in place to allow future versions to add new variables without shifting down storage in the inheritance chain (see [OpenZeppelin's guide about storage gaps](https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps)).
+ uint256[49] private __gap;
+}
+
+/// @title IPlugin
+/// @author Aragon Association - 2022-2023
+/// @notice An interface defining the traits of a plugin.
+/// @custom:security-contact sirt@aragon.org
+interface IPlugin {
+ enum PluginType {
+ UUPS,
+ Cloneable,
+ Constructable
+ }
+
+ /// @notice Returns the plugin's type
+ function pluginType() external view returns (PluginType);
+}
+
+/// @title PluginUUPSUpgradeable
+/// @author Aragon Association - 2022-2023
+/// @notice An abstract, upgradeable contract to inherit from when creating a plugin being deployed via the UUPS pattern (see [ERC-1822](https://eips.ethereum.org/EIPS/eip-1822)).
+/// @custom:security-contact sirt@aragon.org
+abstract contract PluginUUPSUpgradeable is
+ IPlugin,
+ ERC165Upgradeable,
+ UUPSUpgradeable,
+ DaoAuthorizableUpgradeable,
+ ProtocolVersion
+{
+ // NOTE: When adding new state variables to the contract, the size of `_gap` has to be adapted below as well.
+
+ /// @notice Disables the initializers on the implementation contract to prevent it from being left uninitialized.
+ /// @custom:oz-upgrades-unsafe-allow constructor
+ constructor() {
+ _disableInitializers();
+ }
+
+ /// @inheritdoc IPlugin
+ function pluginType() public pure override returns (PluginType) {
+ return PluginType.UUPS;
+ }
+
+ /// @notice The ID of the permission required to call the `_authorizeUpgrade` function.
+ bytes32 public constant UPGRADE_PLUGIN_PERMISSION_ID = keccak256("UPGRADE_PLUGIN_PERMISSION");
+
+ /// @notice Initializes the plugin by storing the associated DAO.
+ /// @param _dao The DAO contract.
+ function __PluginUUPSUpgradeable_init(IDAO _dao) internal virtual onlyInitializing {
+ __DaoAuthorizableUpgradeable_init(_dao);
+ }
+
+ /// @notice Checks if an interface is supported by this or its parent contract.
+ /// @param _interfaceId The ID of the interface.
+ /// @return Returns `true` if the interface is supported.
+ function supportsInterface(bytes4 _interfaceId) public view virtual override returns (bool) {
+ return
+ _interfaceId == type(IPlugin).interfaceId ||
+ _interfaceId == type(IProtocolVersion).interfaceId ||
+ _interfaceId == type(IERC1822ProxiableUpgradeable).interfaceId ||
+ super.supportsInterface(_interfaceId);
+ }
+
+ /// @notice Returns the address of the implementation contract in the [proxy storage slot](https://eips.ethereum.org/EIPS/eip-1967) slot the [UUPS proxy](https://eips.ethereum.org/EIPS/eip-1822) is pointing to.
+ /// @return The address of the implementation contract.
+ function implementation() public view returns (address) {
+ return _getImplementation();
+ }
+
+ /// @notice Internal method authorizing the upgrade of the contract via the [upgradeability mechanism for UUPS proxies](https://docs.openzeppelin.com/contracts/4.x/api/proxy#UUPSUpgradeable) (see [ERC-1822](https://eips.ethereum.org/EIPS/eip-1822)).
+ /// @dev The caller must have the `UPGRADE_PLUGIN_PERMISSION_ID` permission.
+ function _authorizeUpgrade(
+ address
+ ) internal virtual override auth(UPGRADE_PLUGIN_PERMISSION_ID) {}
+
+ /// @notice This empty reserved space is put in place to allow future versions to add new variables without shifting down storage in the inheritance chain (see [OpenZeppelin's guide about storage gaps](https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps)).
+ uint256[50] private __gap;
+}
+
+// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)
+
+// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
+
+/**
+ * @dev Interface of the ERC20 standard as defined in the EIP.
+ */
+interface IERC20 {
+ /**
+ * @dev Emitted when `value` tokens are moved from one account (`from`) to
+ * another (`to`).
+ *
+ * Note that `value` may be zero.
+ */
+ event Transfer(address indexed from, address indexed to, uint256 value);
+
+ /**
+ * @dev Emitted when the allowance of a `spender` for an `owner` is set by
+ * a call to {approve}. `value` is the new allowance.
+ */
+ event Approval(address indexed owner, address indexed spender, uint256 value);
+
+ /**
+ * @dev Returns the amount of tokens in existence.
+ */
+ function totalSupply() external view returns (uint256);
+
+ /**
+ * @dev Returns the amount of tokens owned by `account`.
+ */
+ function balanceOf(address account) external view returns (uint256);
+
+ /**
+ * @dev Moves `amount` tokens from the caller's account to `to`.
+ *
+ * Returns a boolean value indicating whether the operation succeeded.
+ *
+ * Emits a {Transfer} event.
+ */
+ function transfer(address to, uint256 amount) external returns (bool);
+
+ /**
+ * @dev Returns the remaining number of tokens that `spender` will be
+ * allowed to spend on behalf of `owner` through {transferFrom}. This is
+ * zero by default.
+ *
+ * This value changes when {approve} or {transferFrom} are called.
+ */
+ function allowance(address owner, address spender) external view returns (uint256);
+
+ /**
+ * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
+ *
+ * Returns a boolean value indicating whether the operation succeeded.
+ *
+ * IMPORTANT: Beware that changing an allowance with this method brings the risk
+ * that someone may use both the old and the new allowance by unfortunate
+ * transaction ordering. One possible solution to mitigate this race
+ * condition is to first reduce the spender's allowance to 0 and set the
+ * desired value afterwards:
+ * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ *
+ * Emits an {Approval} event.
+ */
+ function approve(address spender, uint256 amount) external returns (bool);
+
+ /**
+ * @dev Moves `amount` tokens from `from` to `to` using the
+ * allowance mechanism. `amount` is then deducted from the caller's
+ * allowance.
+ *
+ * Returns a boolean value indicating whether the operation succeeded.
+ *
+ * Emits a {Transfer} event.
+ */
+ function transferFrom(address from, address to, uint256 amount) external returns (bool);
+}
+
+// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)
+
+// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)
+
+/**
+ * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
+ * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
+ *
+ * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
+ * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
+ * need to send a transaction, and thus is not required to hold Ether at all.
+ */
+interface IERC20Permit {
+ /**
+ * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
+ * given ``owner``'s signed approval.
+ *
+ * IMPORTANT: The same issues {IERC20-approve} has related to transaction
+ * ordering also apply here.
+ *
+ * Emits an {Approval} event.
+ *
+ * Requirements:
+ *
+ * - `spender` cannot be the zero address.
+ * - `deadline` must be a timestamp in the future.
+ * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
+ * over the EIP712-formatted function arguments.
+ * - the signature must use ``owner``'s current nonce (see {nonces}).
+ *
+ * For more information on the signature format, see the
+ * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
+ * section].
+ */
+ function permit(
+ address owner,
+ address spender,
+ uint256 value,
+ uint256 deadline,
+ uint8 v,
+ bytes32 r,
+ bytes32 s
+ ) external;
+
+ /**
+ * @dev Returns the current nonce for `owner`. This value must be
+ * included whenever a signature is generated for {permit}.
+ *
+ * Every successful call to {permit} increases ``owner``'s nonce by one. This
+ * prevents a signature from being used multiple times.
+ */
+ function nonces(address owner) external view returns (uint256);
+
+ /**
+ * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
+ */
+ // solhint-disable-next-line func-name-mixedcase
+ function DOMAIN_SEPARATOR() external view returns (bytes32);
+}
+
+// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
+
+/**
+ * @dev Collection of functions related to the address type
+ */
+library Address {
+ /**
+ * @dev Returns true if `account` is a contract.
+ *
+ * [IMPORTANT]
+ * ====
+ * It is unsafe to assume that an address for which this function returns
+ * false is an externally-owned account (EOA) and not a contract.
+ *
+ * Among others, `isContract` will return false for the following
+ * types of addresses:
+ *
+ * - an externally-owned account
+ * - a contract in construction
+ * - an address where a contract will be created
+ * - an address where a contract lived, but was destroyed
+ *
+ * Furthermore, `isContract` will also return true if the target contract within
+ * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
+ * which only has an effect at the end of a transaction.
+ * ====
+ *
+ * [IMPORTANT]
+ * ====
+ * You shouldn't rely on `isContract` to protect against flash loan attacks!
+ *
+ * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
+ * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
+ * constructor.
+ * ====
+ */
+ function isContract(address account) internal view returns (bool) {
+ // This method relies on extcodesize/address.code.length, which returns 0
+ // for contracts in construction, since the code is only stored at the end
+ // of the constructor execution.
+
+ return account.code.length > 0;
+ }
+
+ /**
+ * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
+ * `recipient`, forwarding all available gas and reverting on errors.
+ *
+ * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
+ * of certain opcodes, possibly making contracts go over the 2300 gas limit
+ * imposed by `transfer`, making them unable to receive funds via
+ * `transfer`. {sendValue} removes this limitation.
+ *
+ * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
+ *
+ * IMPORTANT: because control is transferred to `recipient`, care must be
+ * taken to not create reentrancy vulnerabilities. Consider using
+ * {ReentrancyGuard} or the
+ * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
+ */
+ function sendValue(address payable recipient, uint256 amount) internal {
+ require(address(this).balance >= amount, "Address: insufficient balance");
+
+ (bool success, ) = recipient.call{value: amount}("");
+ require(success, "Address: unable to send value, recipient may have reverted");
+ }
+
+ /**
+ * @dev Performs a Solidity function call using a low level `call`. A
+ * plain `call` is an unsafe replacement for a function call: use this
+ * function instead.
+ *
+ * If `target` reverts with a revert reason, it is bubbled up by this
+ * function (like regular Solidity function calls).
+ *
+ * Returns the raw returned data. To convert to the expected return value,
+ * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
+ *
+ * Requirements:
+ *
+ * - `target` must be a contract.
+ * - calling `target` with `data` must not revert.
+ *
+ * _Available since v3.1._
+ */
+ function functionCall(address target, bytes memory data) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, 0, "Address: low-level call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
+ * `errorMessage` as a fallback revert reason when `target` reverts.
+ *
+ * _Available since v3.1._
+ */
+ function functionCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, 0, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but also transferring `value` wei to `target`.
+ *
+ * Requirements:
+ *
+ * - the calling contract must have an ETH balance of at least `value`.
+ * - the called Solidity function must be `payable`.
+ *
+ * _Available since v3.1._
+ */
+ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
+ return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
+ * with `errorMessage` as a fallback revert reason when `target` reverts.
+ *
+ * _Available since v3.1._
+ */
+ function functionCallWithValue(
+ address target,
+ bytes memory data,
+ uint256 value,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ require(address(this).balance >= value, "Address: insufficient balance for call");
+ (bool success, bytes memory returndata) = target.call{value: value}(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but performing a static call.
+ *
+ * _Available since v3.3._
+ */
+ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
+ return functionStaticCall(target, data, "Address: low-level static call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
+ * but performing a static call.
+ *
+ * _Available since v3.3._
+ */
+ function functionStaticCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal view returns (bytes memory) {
+ (bool success, bytes memory returndata) = target.staticcall(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
+ * but performing a delegate call.
+ *
+ * _Available since v3.4._
+ */
+ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
+ return functionDelegateCall(target, data, "Address: low-level delegate call failed");
+ }
+
+ /**
+ * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
+ * but performing a delegate call.
+ *
+ * _Available since v3.4._
+ */
+ function functionDelegateCall(
+ address target,
+ bytes memory data,
+ string memory errorMessage
+ ) internal returns (bytes memory) {
+ (bool success, bytes memory returndata) = target.delegatecall(data);
+ return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+ }
+
+ /**
+ * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
+ * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
+ *
+ * _Available since v4.8._
+ */
+ function verifyCallResultFromTarget(
+ address target,
+ bool success,
+ bytes memory returndata,
+ string memory errorMessage
+ ) internal view returns (bytes memory) {
+ if (success) {
+ if (returndata.length == 0) {
+ // only check isContract if the call was successful and the return data is empty
+ // otherwise we already know that it was a contract
+ require(isContract(target), "Address: call to non-contract");
+ }
+ return returndata;
+ } else {
+ _revert(returndata, errorMessage);
+ }
+ }
+
+ /**
+ * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
+ * revert reason or using the provided one.
+ *
+ * _Available since v4.3._
+ */
+ function verifyCallResult(
+ bool success,
+ bytes memory returndata,
+ string memory errorMessage
+ ) internal pure returns (bytes memory) {
+ if (success) {
+ return returndata;
+ } else {
+ _revert(returndata, errorMessage);
+ }
+ }
+
+ function _revert(bytes memory returndata, string memory errorMessage) private pure {
+ // Look for revert reason and bubble it up if present
+ if (returndata.length > 0) {
+ // The easiest way to bubble the revert reason is using memory via assembly
+ /// @solidity memory-safe-assembly
+ assembly {
+ let returndata_size := mload(returndata)
+ revert(add(32, returndata), returndata_size)
+ }
+ } else {
+ revert(errorMessage);
+ }
+ }
+}
+
+/**
+ * @title SafeERC20
+ * @dev Wrappers around ERC20 operations that throw on failure (when the token
+ * contract returns false). Tokens that return no value (and instead revert or
+ * throw on failure) are also supported, non-reverting calls are assumed to be
+ * successful.
+ * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
+ * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
+ */
+library SafeERC20 {
+ using Address for address;
+
+ /**
+ * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
+ * non-reverting calls are assumed to be successful.
+ */
+ function safeTransfer(IERC20 token, address to, uint256 value) internal {
+ _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
+ }
+
+ /**
+ * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
+ * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
+ */
+ function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
+ _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
+ }
+
+ /**
+ * @dev Deprecated. This function has issues similar to the ones found in
+ * {IERC20-approve}, and its usage is discouraged.
+ *
+ * Whenever possible, use {safeIncreaseAllowance} and
+ * {safeDecreaseAllowance} instead.
+ */
+ function safeApprove(IERC20 token, address spender, uint256 value) internal {
+ // safeApprove should only be called when setting an initial allowance,
+ // or when resetting it to zero. To increase and decrease it, use
+ // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
+ require(
+ (value == 0) || (token.allowance(address(this), spender) == 0),
+ "SafeERC20: approve from non-zero to non-zero allowance"
+ );
+ _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
+ }
+
+ /**
+ * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
+ * non-reverting calls are assumed to be successful.
+ */
+ function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
+ uint256 oldAllowance = token.allowance(address(this), spender);
+ _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
+ }
+
+ /**
+ * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
+ * non-reverting calls are assumed to be successful.
+ */
+ function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
+ unchecked {
+ uint256 oldAllowance = token.allowance(address(this), spender);
+ require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
+ _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
+ }
+ }
+
+ /**
+ * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
+ * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
+ * to be set to zero before setting it to a non-zero value, such as USDT.
+ */
+ function forceApprove(IERC20 token, address spender, uint256 value) internal {
+ bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
+
+ if (!_callOptionalReturnBool(token, approvalCall)) {
+ _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
+ _callOptionalReturn(token, approvalCall);
+ }
+ }
+
+ /**
+ * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
+ * Revert on invalid signature.
+ */
+ function safePermit(
+ IERC20Permit token,
+ address owner,
+ address spender,
+ uint256 value,
+ uint256 deadline,
+ uint8 v,
+ bytes32 r,
+ bytes32 s
+ ) internal {
+ uint256 nonceBefore = token.nonces(owner);
+ token.permit(owner, spender, value, deadline, v, r, s);
+ uint256 nonceAfter = token.nonces(owner);
+ require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
+ }
+
+ /**
+ * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
+ * on the return value: the return value is optional (but if data is returned, it must not be false).
+ * @param token The token targeted by the call.
+ * @param data The call data (encoded using abi.encode or one of its variants).
+ */
+ function _callOptionalReturn(IERC20 token, bytes memory data) private {
+ // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
+ // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
+ // the target address contains contract code and also asserts for success in the low-level call.
+
+ bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
+ require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
+ }
+
+ /**
+ * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
+ * on the return value: the return value is optional (but if data is returned, it must not be false).
+ * @param token The token targeted by the call.
+ * @param data The call data (encoded using abi.encode or one of its variants).
+ *
+ * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
+ */
+ function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
+ // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
+ // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
+ // and not revert is the subcall reverts.
+
+ (bool success, bytes memory returndata) = address(token).call(data);
+ return
+ success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
+ }
+}
+
+// Formal verification for library and formula: https://twitter.com/Zellic_io/status/1510341868021854209
+
+// ----------------------------------------------------------------------------
+// BokkyPooBah's DateTime Library v1.01
+//
+// A gas-efficient Solidity date and time library
+//
+// https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
+//
+// Tested date range 1970/01/01 to 2345/12/31
+//
+// Conventions:
+// Unit | Range | Notes
+// :-------- |:-------------:|:-----
+// timestamp | >= 0 | Unix timestamp, number of seconds since 1970/01/01 00:00:00 UTC
+// year | 1970 ... 2345 |
+// month | 1 ... 12 |
+// day | 1 ... 31 |
+// hour | 0 ... 23 |
+// minute | 0 ... 59 |
+// second | 0 ... 59 |
+// dayOfWeek | 1 ... 7 | 1 = Monday, ..., 7 = Sunday
+//
+//
+// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018-2019. The MIT Licence.
+// ----------------------------------------------------------------------------
+
+library BokkyPooBahsDateTimeLibrary {
+
+ uint constant SECONDS_PER_DAY = 24 * 60 * 60;
+ uint constant SECONDS_PER_HOUR = 60 * 60;
+ uint constant SECONDS_PER_MINUTE = 60;
+ int constant OFFSET19700101 = 2440588;
+
+ uint constant DOW_MON = 1;
+ uint constant DOW_TUE = 2;
+ uint constant DOW_WED = 3;
+ uint constant DOW_THU = 4;
+ uint constant DOW_FRI = 5;
+ uint constant DOW_SAT = 6;
+ uint constant DOW_SUN = 7;
+
+ // ------------------------------------------------------------------------
+ // Calculate the number of days from 1970/01/01 to year/month/day using
+ // the date conversion algorithm from
+ // https://aa.usno.navy.mil/faq/JD_formula.html
+ // and subtracting the offset 2440588 so that 1970/01/01 is day 0
+ //
+ // days = day
+ // - 32075
+ // + 1461 * (year + 4800 + (month - 14) / 12) / 4
+ // + 367 * (month - 2 - (month - 14) / 12 * 12) / 12
+ // - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4
+ // - offset
+ // ------------------------------------------------------------------------
+ function _daysFromDate(uint year, uint month, uint day) internal pure returns (uint _days) {
+ require(year >= 1970);
+ int _year = int(year);
+ int _month = int(month);
+ int _day = int(day);
+
+ int __days = _day
+ - 32075
+ + 1461 * (_year + 4800 + (_month - 14) / 12) / 4
+ + 367 * (_month - 2 - (_month - 14) / 12 * 12) / 12
+ - 3 * ((_year + 4900 + (_month - 14) / 12) / 100) / 4
+ - OFFSET19700101;
+
+ _days = uint(__days);
+ }
+
+ // ------------------------------------------------------------------------
+ // Calculate year/month/day from the number of days since 1970/01/01 using
+ // the date conversion algorithm from
+ // http://aa.usno.navy.mil/faq/docs/JD_Formula.php
+ // and adding the offset 2440588 so that 1970/01/01 is day 0
+ //
+ // int L = days + 68569 + offset
+ // int N = 4 * L / 146097
+ // L = L - (146097 * N + 3) / 4
+ // year = 4000 * (L + 1) / 1461001
+ // L = L - 1461 * year / 4 + 31
+ // month = 80 * L / 2447
+ // dd = L - 2447 * month / 80
+ // L = month / 11
+ // month = month + 2 - 12 * L
+ // year = 100 * (N - 49) + year + L
+ // ------------------------------------------------------------------------
+ function _daysToDate(uint _days) internal pure returns (uint year, uint month, uint day) {
+ int __days = int(_days);
+
+ int L = __days + 68569 + OFFSET19700101;
+ int N = 4 * L / 146097;
+ L = L - (146097 * N + 3) / 4;
+ int _year = 4000 * (L + 1) / 1461001;
+ L = L - 1461 * _year / 4 + 31;
+ int _month = 80 * L / 2447;
+ int _day = L - 2447 * _month / 80;
+ L = _month / 11;
+ _month = _month + 2 - 12 * L;
+ _year = 100 * (N - 49) + _year + L;
+
+ year = uint(_year);
+ month = uint(_month);
+ day = uint(_day);
+ }
+
+ function timestampFromDate(uint year, uint month, uint day) internal pure returns (uint timestamp) {
+ timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;
+ }
+ function timestampFromDateTime(uint year, uint month, uint day, uint hour, uint minute, uint second) internal pure returns (uint timestamp) {
+ timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + hour * SECONDS_PER_HOUR + minute * SECONDS_PER_MINUTE + second;
+ }
+ function timestampToDate(uint timestamp) internal pure returns (uint year, uint month, uint day) {
+ (year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ }
+ function timestampToDateTime(uint timestamp) internal pure returns (uint year, uint month, uint day, uint hour, uint minute, uint second) {
+ (year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ uint secs = timestamp % SECONDS_PER_DAY;
+ hour = secs / SECONDS_PER_HOUR;
+ secs = secs % SECONDS_PER_HOUR;
+ minute = secs / SECONDS_PER_MINUTE;
+ second = secs % SECONDS_PER_MINUTE;
+ }
+
+ function isValidDate(uint year, uint month, uint day) internal pure returns (bool valid) {
+ if (year >= 1970 && month > 0 && month <= 12) {
+ uint daysInMonth = _getDaysInMonth(year, month);
+ if (day > 0 && day <= daysInMonth) {
+ valid = true;
+ }
+ }
+ }
+ function isValidDateTime(uint year, uint month, uint day, uint hour, uint minute, uint second) internal pure returns (bool valid) {
+ if (isValidDate(year, month, day)) {
+ if (hour < 24 && minute < 60 && second < 60) {
+ valid = true;
+ }
+ }
+ }
+ function isLeapYear(uint timestamp) internal pure returns (bool leapYear) {
+ (uint year,,) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ leapYear = _isLeapYear(year);
+ }
+ function _isLeapYear(uint year) internal pure returns (bool leapYear) {
+ leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
+ }
+ function isWeekDay(uint timestamp) internal pure returns (bool weekDay) {
+ weekDay = getDayOfWeek(timestamp) <= DOW_FRI;
+ }
+ function isWeekEnd(uint timestamp) internal pure returns (bool weekEnd) {
+ weekEnd = getDayOfWeek(timestamp) >= DOW_SAT;
+ }
+ function getDaysInMonth(uint timestamp) internal pure returns (uint daysInMonth) {
+ (uint year, uint month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ daysInMonth = _getDaysInMonth(year, month);
+ }
+ function _getDaysInMonth(uint year, uint month) internal pure returns (uint daysInMonth) {
+ if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
+ daysInMonth = 31;
+ } else if (month != 2) {
+ daysInMonth = 30;
+ } else {
+ daysInMonth = _isLeapYear(year) ? 29 : 28;
+ }
+ }
+ // 1 = Monday, 7 = Sunday
+ function getDayOfWeek(uint timestamp) internal pure returns (uint dayOfWeek) {
+ uint _days = timestamp / SECONDS_PER_DAY;
+ dayOfWeek = (_days + 3) % 7 + 1;
+ }
+
+ function getYear(uint timestamp) internal pure returns (uint year) {
+ (year,,) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ }
+ function getMonth(uint timestamp) internal pure returns (uint month) {
+ (,month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ }
+ function getDay(uint timestamp) internal pure returns (uint day) {
+ (,,day) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ }
+ function getHour(uint timestamp) internal pure returns (uint hour) {
+ uint secs = timestamp % SECONDS_PER_DAY;
+ hour = secs / SECONDS_PER_HOUR;
+ }
+ function getMinute(uint timestamp) internal pure returns (uint minute) {
+ uint secs = timestamp % SECONDS_PER_HOUR;
+ minute = secs / SECONDS_PER_MINUTE;
+ }
+ function getSecond(uint timestamp) internal pure returns (uint second) {
+ second = timestamp % SECONDS_PER_MINUTE;
+ }
+
+ function addYears(uint timestamp, uint _years) internal pure returns (uint newTimestamp) {
+ (uint year, uint month, uint day) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ year += _years;
+ uint daysInMonth = _getDaysInMonth(year, month);
+ if (day > daysInMonth) {
+ day = daysInMonth;
+ }
+ newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
+ require(newTimestamp >= timestamp);
+ }
+ function addMonths(uint timestamp, uint _months) internal pure returns (uint newTimestamp) {
+ (uint year, uint month, uint day) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ month += _months;
+ year += (month - 1) / 12;
+ month = (month - 1) % 12 + 1;
+ uint daysInMonth = _getDaysInMonth(year, month);
+ if (day > daysInMonth) {
+ day = daysInMonth;
+ }
+ newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
+ require(newTimestamp >= timestamp);
+ }
+ function addDays(uint timestamp, uint _days) internal pure returns (uint newTimestamp) {
+ newTimestamp = timestamp + _days * SECONDS_PER_DAY;
+ require(newTimestamp >= timestamp);
+ }
+ function addHours(uint timestamp, uint _hours) internal pure returns (uint newTimestamp) {
+ newTimestamp = timestamp + _hours * SECONDS_PER_HOUR;
+ require(newTimestamp >= timestamp);
+ }
+ function addMinutes(uint timestamp, uint _minutes) internal pure returns (uint newTimestamp) {
+ newTimestamp = timestamp + _minutes * SECONDS_PER_MINUTE;
+ require(newTimestamp >= timestamp);
+ }
+ function addSeconds(uint timestamp, uint _seconds) internal pure returns (uint newTimestamp) {
+ newTimestamp = timestamp + _seconds;
+ require(newTimestamp >= timestamp);
+ }
+
+ function subYears(uint timestamp, uint _years) internal pure returns (uint newTimestamp) {
+ (uint year, uint month, uint day) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ year -= _years;
+ uint daysInMonth = _getDaysInMonth(year, month);
+ if (day > daysInMonth) {
+ day = daysInMonth;
+ }
+ newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
+ require(newTimestamp <= timestamp);
+ }
+ function subMonths(uint timestamp, uint _months) internal pure returns (uint newTimestamp) {
+ (uint year, uint month, uint day) = _daysToDate(timestamp / SECONDS_PER_DAY);
+ uint yearMonth = year * 12 + (month - 1) - _months;
+ year = yearMonth / 12;
+ month = yearMonth % 12 + 1;
+ uint daysInMonth = _getDaysInMonth(year, month);
+ if (day > daysInMonth) {
+ day = daysInMonth;
+ }
+ newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
+ require(newTimestamp <= timestamp);
+ }
+ function subDays(uint timestamp, uint _days) internal pure returns (uint newTimestamp) {
+ newTimestamp = timestamp - _days * SECONDS_PER_DAY;
+ require(newTimestamp <= timestamp);
+ }
+ function subHours(uint timestamp, uint _hours) internal pure returns (uint newTimestamp) {
+ newTimestamp = timestamp - _hours * SECONDS_PER_HOUR;
+ require(newTimestamp <= timestamp);
+ }
+ function subMinutes(uint timestamp, uint _minutes) internal pure returns (uint newTimestamp) {
+ newTimestamp = timestamp - _minutes * SECONDS_PER_MINUTE;
+ require(newTimestamp <= timestamp);
+ }
+ function subSeconds(uint timestamp, uint _seconds) internal pure returns (uint newTimestamp) {
+ newTimestamp = timestamp - _seconds;
+ require(newTimestamp <= timestamp);
+ }
+
+ function diffYears(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _years) {
+ require(fromTimestamp <= toTimestamp);
+ (uint fromYear,,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
+ (uint toYear,,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
+ _years = toYear - fromYear;
+ }
+ function diffMonths(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _months) {
+ require(fromTimestamp <= toTimestamp);
+ (uint fromYear, uint fromMonth,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
+ (uint toYear, uint toMonth,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
+ _months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
+ }
+ function diffDays(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _days) {
+ require(fromTimestamp <= toTimestamp);
+ _days = (toTimestamp - fromTimestamp) / SECONDS_PER_DAY;
+ }
+ function diffHours(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _hours) {
+ require(fromTimestamp <= toTimestamp);
+ _hours = (toTimestamp - fromTimestamp) / SECONDS_PER_HOUR;
+ }
+ function diffMinutes(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _minutes) {
+ require(fromTimestamp <= toTimestamp);
+ _minutes = (toTimestamp - fromTimestamp) / SECONDS_PER_MINUTE;
+ }
+ function diffSeconds(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _seconds) {
+ require(fromTimestamp <= toTimestamp);
+ _seconds = toTimestamp - fromTimestamp;
+ }
+}
+
+type EncodedTimeShift is bytes6;
+
+struct TimeShift {
+ TimeShiftLib.TimeUnit unit;
+ int40 offset;
+}
+
+function encode(TimeShift memory shift) pure returns (EncodedTimeShift) {
+ return EncodedTimeShift.wrap(bytes6(abi.encodePacked(uint8(shift.unit), shift.offset)));
+}
+
+function decode(EncodedTimeShift encoded) pure returns (TimeShiftLib.TimeUnit unit, int40 offset) {
+ uint48 encodedValue = uint48(EncodedTimeShift.unwrap(encoded));
+ unit = TimeShiftLib.TimeUnit(uint8(encodedValue >> 40));
+ offset = int40(uint40(uint48(encodedValue)));
+}
+
+// Note this is an efficient way to check for inherited time shifts
+// Even if an offset is specified, it will be ignored, but it is still
+// considered an inherited time shift
+function isInherited(EncodedTimeShift encoded) pure returns (bool) {
+ return EncodedTimeShift.unwrap(encoded) < 0x010000000000;
+}
+
+// Note this is an efficient way to check for non-recurrent time shifts
+// Any value lower than 0x070000000000 is a recurrent time shift
+function isNonRecurrent(EncodedTimeShift encoded) pure returns (bool) {
+ return EncodedTimeShift.unwrap(encoded) > 0x06ffffffffff;
+}
+
+using { decode, isInherited, isNonRecurrent } for EncodedTimeShift global;
+using { encode } for TimeShift global;
+
+library TimeShiftLib {
+ using TimeShiftLib for *;
+
+ enum TimeUnit {
+ Inherit,
+ Daily, // 1
+ Weekly, // 2
+ Monthly, // 3
+ Quarterly, // 4
+ Semiyearly, // 5
+ Yearly, // 6
+ NonRecurrent
+ }
+
+ error InvalidTimeShift();
+
+ // solhint-disable-next-line code-complexity
+ function applyShift(uint40 time, EncodedTimeShift shift) internal pure returns (uint40) {
+ (TimeUnit unit, int40 offset) = shift.decode();
+
+ if (unit == TimeUnit.NonRecurrent) {
+ // Ensure offset is positive and in the future
+ // (We cast to int48 so we don't overflow for any possible uint40 value)
+ if (int48(offset) > int48(uint48(time))) {
+ return uint40(offset);
+ } else {
+ revert InvalidTimeShift();
+ }
+ }
+
+ uint40 realTime = uint40(int40(time) + offset);
+ (uint256 y, uint256 m, uint256 d) = realTime.toDate();
+
+ // Gas opt: split branches for shorter paths and handle the most common cases first
+ if (uint8(unit) > 3) {
+ if (unit == TimeUnit.Yearly) {
+ (y, m, d) = (y + 1, 1, 1);
+ } else if (unit == TimeUnit.Quarterly) {
+ (y, m, d) = m < 10 ? (y, (1 + (m - 1) / 3) * 3 + 1, 1) : (y + 1, 1, 1);
+ } else if (unit == TimeUnit.Semiyearly) {
+ (y, m, d) = m < 7 ? (y, 7, 1) : (y + 1, 1, 1);
+ } else {
+ revert InvalidTimeShift();
+ }
+ } else {
+ if (unit == TimeUnit.Monthly) {
+ (y, m, d) = m < 12 ? (y, m + 1, 1) : (y + 1, 1, 1);
+ } else if (unit == TimeUnit.Weekly) {
+ (y, m, d) = addDays(y, m, d, 8 - BokkyPooBahsDateTimeLibrary.getDayOfWeek(realTime));
+ } else if (unit == TimeUnit.Daily) {
+ (y, m, d) = addDays(y, m, d, 1);
+ } else {
+ revert InvalidTimeShift();
+ }
+ }
+
+ // All time shifts are relative to the beginning of the day UTC before removing the offset
+ uint256 shiftedTs = BokkyPooBahsDateTimeLibrary.timestampFromDateTime(y, m, d, 0, 0, 0);
+ return uint40(int40(uint40(shiftedTs)) - offset);
+ }
+
+ /**
+ * @dev IT WILL ONLY TRANSITION ONE MONTH IF NECESSARY
+ */
+ function addDays(
+ uint256 y,
+ uint256 m,
+ uint256 d,
+ uint256 daysToAdd
+ )
+ private
+ pure
+ returns (uint256, uint256, uint256)
+ {
+ uint256 daysInMonth = BokkyPooBahsDateTimeLibrary._getDaysInMonth(y, m);
+ uint256 d2 = d + daysToAdd;
+
+ return d2 <= daysInMonth ? (y, m, d2) : m < 12 ? (y, m + 1, d2 - daysInMonth) : (y + 1, 1, d2 - daysInMonth);
+ }
+
+ function toDate(uint40 timestamp) internal pure returns (uint256 y, uint256 m, uint256 d) {
+ return BokkyPooBahsDateTimeLibrary._daysToDate(timestamp / 1 days);
+ }
+}
+
+address constant NATIVE_ASSET = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
+uint256 constant NO_PARENT_ID = 0;
+uint256 constant INHERITED_AMOUNT = 0;
+uint40 constant INHERITED_RESET_TIME = 0;
+string constant TRANSFER_SIG = "transfer(address,uint256)";
+
+/**
+ * @title Budget
+ * @author DAOBox (Security@DAOBox.app)
+ * @notice Budgeting module for efficient spending from an Aragon OSx DAO using allowance chains
+ * to delegate spending authority
+ */
+contract Budget is PluginUUPSUpgradeable {
+ bytes32 public constant ROOT_BUDGET_PERMISSION_ID = keccak256("ROOT_BUDGET_PERMISSION");
+
+ using TimeShiftLib for uint40;
+ using SafeERC20 for IERC20;
+
+ struct Allowance {
+ uint256 parentId;
+ uint256 amount;
+ uint256 spent;
+ address token;
+ uint40 nextResetTime;
+ address spender;
+ EncodedTimeShift recurrency;
+ bool isDisabled;
+ }
+
+ mapping(uint256 => Allowance) public allowances;
+ uint256 public allowancesCount;
+ uint256 private nonce;
+
+ event AllowanceCreated(
+ uint256 indexed allowanceId,
+ uint256 indexed parentAllowanceId,
+ address indexed spender,
+ address token,
+ uint256 amount,
+ EncodedTimeShift recurrency,
+ uint40 nextResetTime,
+ string name
+ );
+ event AllowanceStateChanged(uint256 indexed allowanceId, bool isEnabled);
+ event AllowanceAmountChanged(uint256 allowanceId, uint256 amount);
+ event AllowanceSpenderChanged(uint256 allowanceId, address spender);
+ event AllowanceNameChanged(uint256 allowanceId, string name);
+ event PaymentExecuted(
+ uint256 indexed allowanceId,
+ address indexed actor,
+ address token,
+ address indexed to,
+ uint256 amount,
+ uint40 nextResetTime,
+ string description
+ );
+ event MultiPaymentExecuted(
+ uint256 indexed allowanceId,
+ address indexed actor,
+ address token,
+ address[] tos,
+ uint256[] amounts,
+ uint40 nextResetTime,
+ string description
+ );
+ event AllowanceDebited(
+ uint256 indexed allowanceId,
+ address indexed actor,
+ address token,
+ uint256 amount,
+ uint40 nextResetTime,
+ bytes description
+ );
+
+ error UnexistentAllowance(uint256 allowanceId);
+ error DisabledAllowance(uint256 allowanceId);
+ error UnauthorizedNotAllowanceAdmin(uint256 allowanceId);
+ error TokenMismatch(address patentToken, address childToken);
+ error InheritedAmountNotAllowed();
+ error ZeroAmountPayment();
+ error BadInput();
+ error UnauthorizedPaymentExecution(uint256 allowanceId, address actor);
+ error Overbudget(uint256 allowanceId, uint256 amount, uint256 remainingBudget);
+ error PaymentExecutionFailed(uint256 allowanceId, address token, address to, uint256 amount);
+ error NativeValueMismatch();
+ error UnauthorizedNotDao();
+
+ constructor() {
+ _disableInitializers();
+ }
+
+ /// @notice Initializes the plugin when build 1 is installed.
+ function initialize(IDAO _dao) external initializer {
+ __PluginUUPSUpgradeable_init(_dao);
+ nonce = 0;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // ALLOWANCE MANAGEMENT
+ ////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * @notice Creates a new allowance giving permission to spend funds from the dao to a given address or addresses
+ * with a certain role
+ * @dev Note 1: that child allowances can be greater than the allowed amount of its parent budget and have different
+ * recurrency
+ * Note 2: It is possible to create child allowances for allowances that are disabled (either its parent disabled or
+ * any of its ancestors up to the top-level)
+ * @param parentAllowanceId ID for the parent allowance (value is 0 for top-level allowances without dependencies)
+ * @param spender Address or role identifier of the entities authorized to execute payments from this allowance
+ * @param token Address of the token (must be the same as the parent's token)
+ * @param amount Amount of token that can be spent per period
+ * @param recurrency Unit of time for the allowance spent amount to be reset (value is 0 for the allowance to
+ * inherit its parent's recurrency)
+ * @param name Name of the allowance being created
+ * @return allowanceId ID of the allowance created
+ */
+ // solhint-disable-next-line code-complexity
+ function createAllowance(
+ uint256 parentAllowanceId,
+ address spender,
+ address token,
+ uint256 amount,
+ EncodedTimeShift recurrency,
+ string memory name
+ )
+ public
+ returns (uint256 allowanceId)
+ {
+ uint40 nextResetTime;
+
+ if (spender == address(0) || token == address(0)) {
+ revert BadInput();
+ }
+
+ if (parentAllowanceId == NO_PARENT_ID) {
+ // Top-level allowances can only be created by the dao
+ if (_msgSender() != address(dao())) {
+ revert UnauthorizedNotDao();
+ }
+
+ // We don't allow setting inherited amounts on top-level allowances as
+ // it could be prone to a client-side mistake to send 0 as the amount which will
+ // create an allowance that allows completely wiping the dao (for the token)
+ if (amount == INHERITED_AMOUNT) {
+ revert InheritedAmountNotAllowed();
+ }
+
+ // For top-level allowances, recurrency needs to be set and cannot be zero (inherited)
+ // applyShift reverts with InvalidTimeShift if recurrency is unspecified
+ // Therefore, nextResetTime is always greater than the current time
+ nextResetTime = uint40(block.timestamp).applyShift(recurrency);
+ } else {
+ // Reverts if parentAllowanceId doesn't exist
+ Allowance storage parentAllowance = _getAllowance(parentAllowanceId);
+
+ // Not checking whether the parentAllowance is enabled is an explicit decision
+ // Disabling any allowance in a given allowance chain will result in all its
+ // children not being able to execute payments
+ // This allows for disabling a certain allowance to reconfigure the whole tree
+ // of sub-allowances below it, before enabling it again
+
+ // Sub-allowances can be created by entities authorized to spend from a particular allowance
+ if (_msgSender() != parentAllowance.spender) {
+ revert UnauthorizedNotAllowanceAdmin(parentAllowanceId);
+ }
+
+ if (token != parentAllowance.token) {
+ revert TokenMismatch(parentAllowance.token, token);
+ }
+ // Recurrency can be zero in sub-allowances and is inherited from the parent
+ if (!recurrency.isInherited()) {
+ // If recurrency is not inherited, amount cannot be inherited
+ if (amount == INHERITED_AMOUNT) {
+ revert InheritedAmountNotAllowed();
+ }
+
+ // Will revert with InvalidTimeShift if recurrency is invalid
+ nextResetTime = uint40(block.timestamp).applyShift(recurrency);
+ }
+ }
+
+ // TODO: Check if this is nessaary
+ // Checks that if it is a role flag, a roles instance has been set and the role exists
+ // _validateAuthorizedAddress(spender);
+
+ unchecked {
+ // The index of the first allowance is 1, so NO_PARENT_ID can be 0 (optimization)
+ allowanceId = ++allowancesCount;
+ }
+
+ Allowance storage allowance = allowances[allowanceId];
+ if (parentAllowanceId != NO_PARENT_ID) {
+ allowance.parentId = parentAllowanceId;
+ }
+ if (nextResetTime != INHERITED_RESET_TIME) {
+ allowance.recurrency = recurrency;
+ allowance.nextResetTime = nextResetTime;
+ }
+ allowance.spender = spender;
+ allowance.token = token;
+ allowance.amount = amount;
+
+ emit AllowanceCreated(allowanceId, parentAllowanceId, spender, token, amount, recurrency, nextResetTime, name);
+ }
+
+ /**
+ * @notice Changes the enabled/disabled state of the allowance
+ * @dev Note: Disabling an allowance will implicitly disable payments from all its descendant allowances
+ * @param allowanceId ID of the allowance whose state is being changed
+ * @param isEnabled Whether to enable or disable the allowance
+ */
+ function setAllowanceState(uint256 allowanceId, bool isEnabled) external {
+ Allowance storage allowance = _getAllowanceAndValidateAdmin(allowanceId);
+ allowance.isDisabled = !isEnabled;
+ emit AllowanceStateChanged(allowanceId, isEnabled);
+ }
+
+ /**
+ * @notice Changes the amount that an allowance can spend
+ * @dev Note: It is possible to decrease the amount in an allowance to a smaller amount of what's already been spent
+ * which will cause the allowance not to be able to execute any more payments until it resets (and the new amount
+ * will be enforced)
+ * @param allowanceId ID of the allowance whose amount is being changed
+ * @param amount New allowance amount to be set
+ */
+ function setAllowanceAmount(uint256 allowanceId, uint256 amount) external {
+ Allowance storage allowance = _getAllowanceAndValidateAdmin(allowanceId);
+
+ // Same checks for what allowances can have an inherited amount as in the creation
+ if (amount == INHERITED_AMOUNT && (allowance.parentId == NO_PARENT_ID || !allowance.recurrency.isInherited())) {
+ revert InheritedAmountNotAllowed();
+ }
+
+ allowance.amount = amount;
+ emit AllowanceAmountChanged(allowanceId, amount);
+ }
+
+ /**
+ * @notice Changes the spender of an allowance
+ * @dev Note: Changing the spender also changes who the admin is for all the sub-allowances
+ * @param allowanceId ID of the allowance whose spender is being changed
+ * @param spender New spender account for the allowance
+ */
+ function setAllowanceSpender(uint256 allowanceId, address spender) external {
+ if (spender == address(0)) {
+ revert BadInput();
+ }
+
+ // _validateAuthorizedAddress(spender);
+
+ Allowance storage allowance = _getAllowanceAndValidateAdmin(allowanceId);
+ allowance.spender = spender;
+ emit AllowanceSpenderChanged(allowanceId, spender);
+ }
+
+ /**
+ * @notice Changes the name of an allowance
+ * @dev Note: This has no on-chain side-effects and only emits an event for off-chain consumption
+ * @param allowanceId ID of the allowance whose name is being changed
+ * @param name New name for the allowance
+ */
+ function setAllowanceName(uint256 allowanceId, string memory name) external {
+ _getAllowanceAndValidateAdmin(allowanceId);
+ emit AllowanceNameChanged(allowanceId, name);
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // PAYMENT EXECUTION
+ ////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * @notice Executes a payment from an allowance
+ * @param allowanceId ID of the allowance from which the payment is made
+ * @param to Address that will receive the payment
+ * @param amount Amount of the allowance's token being sent
+ * @param description Description of the payment
+ */
+ function executePayment(
+ uint256 allowanceId,
+ address to,
+ uint256 amount,
+ string memory description
+ )
+ external
+ returns (uint40 nextResetTime)
+ {
+ Allowance storage allowance = _getAllowance(allowanceId);
+
+ if (_msgSender() != allowance.spender) {
+ revert UnauthorizedPaymentExecution(allowanceId, _msgSender());
+ }
+
+ if (amount == 0) {
+ revert ZeroAmountPayment();
+ }
+
+ address token = allowance.token;
+
+ // Make sure the payment is within budget all the way up to its top-level budget
+ (nextResetTime,) = _checkAndUpdateAllowanceChain(allowanceId, amount, add);
+
+ if (!_performTransfer(token, to, amount)) {
+ revert PaymentExecutionFailed(allowanceId, token, to, amount);
+ }
+
+ emit PaymentExecuted(allowanceId, _msgSender(), token, to, amount, nextResetTime, description);
+ }
+
+ function _checkAndUpdateAllowanceChain(
+ uint256 allowanceId,
+ uint256 amount,
+ function(uint256, uint256) pure returns (uint256) op
+ )
+ internal
+ returns (uint40 nextResetTime, bool allowanceResets)
+ {
+ // Can do 'unsafely' as this function only used when allowanceId always points to an allowance which exists
+ // (checked through _getAllowance or a parentId which always exists)
+ Allowance storage allowance = allowances[allowanceId];
+
+ if (allowance.isDisabled) {
+ revert DisabledAllowance(allowanceId);
+ }
+
+ if (allowance.nextResetTime == INHERITED_RESET_TIME) {
+ // Note that since top-level allowances are not allowed to have an inherited reset time,
+ // this branch is only ever executed for sub-allowances (which always have a parentId)
+ (nextResetTime, allowanceResets) = _checkAndUpdateAllowanceChain(allowance.parentId, amount, op);
+ } else {
+ nextResetTime = allowance.nextResetTime;
+
+ // Reset time has past, so we need to reset the allowance
+ if (uint40(block.timestamp) >= nextResetTime) {
+ EncodedTimeShift recurrency = allowance.recurrency;
+ // For a non-recurrent allowance, after the reset time has passed,
+ // the allowance is disabled and cannot be used anymore
+ if (recurrency.isNonRecurrent()) {
+ revert DisabledAllowance(allowanceId);
+ } else {
+ allowanceResets = true;
+ nextResetTime = uint40(block.timestamp).applyShift(recurrency);
+ allowance.nextResetTime = nextResetTime;
+ }
+ }
+
+ // Recursively update all parent allowances before checking the amounts (inheritance forces this)
+ if (allowance.parentId != NO_PARENT_ID) {
+ _checkAndUpdateAllowanceChain(allowance.parentId, amount, op);
+ }
+ }
+
+ if (allowance.amount != INHERITED_AMOUNT) {
+ uint256 spentAfter = op(allowanceResets ? 0 : allowance.spent, amount);
+ if (spentAfter > allowance.amount) {
+ revert Overbudget(allowanceId, amount, allowance.amount - allowance.spent);
+ }
+
+ allowance.spent = spentAfter;
+ }
+ }
+
+ function _performTransfer(address token, address to, uint256 amount) internal returns (bool) {
+ if (token == NATIVE_ASSET) {
+ IDAO.Action[] memory actions = new IDAO.Action[](1);
+ actions[0] = IDAO.Action({ to: to, value: amount, data: "" });
+
+ (, uint256 failureMap) =
+ dao().execute({ _callId: bytes32(nonce++), _actions: actions, _allowFailureMap: 0 });
+ return failureMap == 0 ? true : false;
+ } else {
+ IDAO.Action[] memory actions = new IDAO.Action[](1);
+ bytes memory transferFunctionData = abi.encodeWithSignature(TRANSFER_SIG, to, amount);
+
+ actions[0] = IDAO.Action({ to: token, value: 0, data: transferFunctionData });
+
+ (, uint256 failureMap) =
+ dao().execute({ _callId: bytes32(nonce++), _actions: actions, _allowFailureMap: 0 });
+ return failureMap == 0 ? true : false;
+ }
+ }
+
+ /**
+ * @notice Executes multiple payments from an allowance
+ * @param allowanceId ID of the allowance from which payments are made
+ * @param tos Addresses that will receive the payment
+ * @param amounts Amounts of the allowance's token being sent
+ * @param description Description of the payments
+ */
+ function executeMultiPayment(
+ uint256 allowanceId,
+ address[] calldata tos,
+ uint256[] calldata amounts,
+ string memory description
+ )
+ external
+ returns (uint40 nextResetTime)
+ {
+ Allowance storage allowance = _getAllowance(allowanceId);
+
+ if (_msgSender() != allowance.spender) {
+ revert UnauthorizedPaymentExecution(allowanceId, _msgSender());
+ }
+
+ uint256 count = tos.length;
+ if (count == 0 || count != amounts.length) {
+ revert BadInput();
+ }
+
+ uint256 totalAmount = 0;
+ for (uint256 i = 0; i < count;) {
+ if (amounts[i] == 0) {
+ revert ZeroAmountPayment();
+ }
+
+ totalAmount += amounts[i];
+
+ unchecked {
+ i++;
+ }
+ }
+
+ (nextResetTime,) = _checkAndUpdateAllowanceChain(allowanceId, totalAmount, add);
+
+ address token = allowance.token;
+
+ for (uint256 i = 0; i < count; i++) {
+ if (!_performTransfer(token, tos[i], amounts[i])) {
+ revert PaymentExecutionFailed(allowanceId, token, tos[i], amounts[i]);
+ }
+ }
+
+ emit MultiPaymentExecuted(allowanceId, _msgSender(), token, tos, amounts, nextResetTime, description);
+ }
+
+ /**
+ * @notice Deposit funds into dao debiting funds into an allowance. Frequently used to return a payment
+ * @dev Anyone is allowed to perform this action, independently of whether they could have spent funds in the first
+ * place
+ * @param allowanceId ID of the allowance to be debited (along with its ancester tree)
+ * @param amount Amount being debited
+ * @param description Description of the debit
+ */
+ function debitAllowance(
+ uint256 allowanceId,
+ uint256 amount,
+ bytes calldata description
+ )
+ external
+ payable
+ returns (uint40 nextResetTime)
+ {
+ Allowance storage allowance = _getAllowance(allowanceId);
+ address actor = _msgSender();
+ address payable safeAddr = payable(address(dao()));
+ uint256 balanceDelta = 0;
+
+ // Since funds are going to the dao which is trusted we don't need to follow checks-effects-interactions
+ // A malicious token could re-enter, but it would only have effects in allowances for that bad token
+ // And we don't need to worry about 'callbacks' since the dao is always the receiver and shouldn't do it
+ if (allowance.token != NATIVE_ASSET) {
+ if (msg.value != 0) {
+ revert NativeValueMismatch();
+ }
+
+ IERC20 token = IERC20(allowance.token);
+ uint256 prevBalance = token.balanceOf(safeAddr);
+ token.safeTransferFrom(actor, safeAddr, amount);
+ balanceDelta = token.balanceOf(safeAddr) - prevBalance;
+ } else {
+ if (msg.value != amount) {
+ revert NativeValueMismatch();
+ }
+
+ safeAddr.transfer(amount);
+ balanceDelta = amount; // For native asset transfers, assume balance delta is the amount
+ }
+
+ (nextResetTime,) = _checkAndUpdateAllowanceChain(allowanceId, balanceDelta, zeroCappedSub);
+
+ emit AllowanceDebited(allowanceId, actor, allowance.token, amount, nextResetTime, description);
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // INTERNAL FUNCTIONS
+ ////////////////////////////////////////////////////////////////////////////////
+
+ function _getAllowance(uint256 allowanceId) internal view returns (Allowance storage allowance) {
+ allowance = allowances[allowanceId];
+
+ if (allowance.spender == address(0)) {
+ revert UnexistentAllowance(allowanceId);
+ }
+ }
+
+ function _getAllowanceAndValidateAdmin(uint256 allowanceId) internal view returns (Allowance storage allowance) {
+ allowance = _getAllowance(allowanceId);
+ if (!_isAdminOnAllowance(allowance, _msgSender())) {
+ revert UnauthorizedNotAllowanceAdmin(allowance.parentId);
+ }
+ }
+
+ function isAdminOnAllowance(uint256 allowanceId, address actor) public view returns (bool) {
+ return _isAdminOnAllowance(_getAllowance(allowanceId), actor);
+ }
+
+ function _isAdminOnAllowance(Allowance storage allowance, address actor) internal view returns (bool) {
+ // Changes to the allowance state can be done by the same entity that could
+ // create that allowance in the first place (a spender of the parent allowance)
+ // In the case of top-level allowances, only the dao can enable/disable them
+ // For child allowances, spenders of the parent can change the state of the child
+ uint256 parentId = allowance.parentId;
+ return parentId == NO_PARENT_ID ? actor == address(dao()) : actor == allowances[parentId].spender;
+ }
+
+ function add(uint256 a, uint256 b) internal pure returns (uint256) {
+ return a + b;
+ }
+
+ function zeroCappedSub(uint256 a, uint256 b) internal pure returns (uint256) {
+ return a > b ? a - b : 0;
+ }
+
+ /// @notice This empty reserved space is put in place to allow future versions to add new variables without shifting
+ /// down storage in the inheritance chain (see [OpenZepplins guide about storage
+ /// gaps](https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps)).
+ uint256[50] private __gap;
+}
+
diff --git a/packages/contracts/package.json b/packages/contracts/package.json
new file mode 100644
index 0000000..5bf6c96
--- /dev/null
+++ b/packages/contracts/package.json
@@ -0,0 +1,39 @@
+{
+ "name": "@daobox/budget",
+ "description": "",
+ "version": "1.0.0",
+ "author": {
+ "name": "DAObox",
+ "url": "https://github.com/DAObox"
+ },
+ "devDependencies": {
+ "prettier": "^3.0.0"
+ },
+ "keywords": [
+ "blockchain",
+ "ethereum",
+ "forge",
+ "foundry",
+ "smart-contracts",
+ "solidity",
+ "aragon",
+ "osx",
+ "dao",
+ "daobox"
+ ],
+ "private": true,
+ "scripts": {
+ "clean": "rm -rf cache out",
+ "build": "forge build",
+ "lint": "pnpm lint:sol && pnpm prettier:check",
+ "lint:sol": "forge fmt --check && pnpm solhint {script,src,test}/**/*.sol",
+ "prettier:check": "prettier --check **/*.{json,md,yml} --ignore-path=.prettierignore",
+ "prettier:write": "prettier --write **/*.{json,md,yml} --ignore-path=.prettierignore",
+ "test": "forge test -vvv",
+ "test:coverage": "forge coverage",
+ "test:coverage:report": "forge coverage --report lcov && genhtml lcov.info --branch-coverage --output-dir coverage"
+ },
+ "dependencies": {
+ "solhint": "^3.6.2"
+ }
+}
diff --git a/packages/contracts/pnpm-lock.yaml b/packages/contracts/pnpm-lock.yaml
new file mode 100644
index 0000000..464f747
--- /dev/null
+++ b/packages/contracts/pnpm-lock.yaml
@@ -0,0 +1,468 @@
+lockfileVersion: '6.0'
+
+dependencies:
+ solhint:
+ specifier: ^3.6.2
+ version: 3.6.2
+
+devDependencies:
+ prettier:
+ specifier: ^3.0.0
+ version: 3.0.0
+
+packages:
+
+ /@babel/code-frame@7.22.5:
+ resolution: {integrity: sha512-Xmwn266vad+6DAqEB2A6V/CcZVp62BbwVmcOJc2RPuwih1kw02TjQvWVWlcKGbBPd+8/0V5DEkOcizRGYsspYQ==}
+ engines: {node: '>=6.9.0'}
+ dependencies:
+ '@babel/highlight': 7.22.5
+ dev: false
+
+ /@babel/helper-validator-identifier@7.22.5:
+ resolution: {integrity: sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==}
+ engines: {node: '>=6.9.0'}
+ dev: false
+
+ /@babel/highlight@7.22.5:
+ resolution: {integrity: sha512-BSKlD1hgnedS5XRnGOljZawtag7H1yPfQp0tdNJCHoH6AZ+Pcm9VvkrK59/Yy593Ypg0zMxH2BxD1VPYUQ7UIw==}
+ engines: {node: '>=6.9.0'}
+ dependencies:
+ '@babel/helper-validator-identifier': 7.22.5
+ chalk: 2.4.2
+ js-tokens: 4.0.0
+ dev: false
+
+ /@solidity-parser/parser@0.16.1:
+ resolution: {integrity: sha512-PdhRFNhbTtu3x8Axm0uYpqOy/lODYQK+MlYSgqIsq2L8SFYEHJPHNUiOTAJbDGzNjjr1/n9AcIayxafR/fWmYw==}
+ dependencies:
+ antlr4ts: 0.5.0-alpha.4
+ dev: false
+
+ /ajv@6.12.6:
+ resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+ dependencies:
+ fast-deep-equal: 3.1.3
+ fast-json-stable-stringify: 2.1.0
+ json-schema-traverse: 0.4.1
+ uri-js: 4.4.1
+ dev: false
+
+ /ajv@8.12.0:
+ resolution: {integrity: sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==}
+ dependencies:
+ fast-deep-equal: 3.1.3
+ json-schema-traverse: 1.0.0
+ require-from-string: 2.0.2
+ uri-js: 4.4.1
+ dev: false
+
+ /ansi-regex@5.0.1:
+ resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+ engines: {node: '>=8'}
+ dev: false
+
+ /ansi-styles@3.2.1:
+ resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==}
+ engines: {node: '>=4'}
+ dependencies:
+ color-convert: 1.9.3
+ dev: false
+
+ /ansi-styles@4.3.0:
+ resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+ engines: {node: '>=8'}
+ dependencies:
+ color-convert: 2.0.1
+ dev: false
+
+ /antlr4@4.13.0:
+ resolution: {integrity: sha512-zooUbt+UscjnWyOrsuY/tVFL4rwrAGwOivpQmvmUDE22hy/lUA467Rc1rcixyRwcRUIXFYBwv7+dClDSHdmmew==}
+ engines: {node: '>=16'}
+ dev: false
+
+ /antlr4ts@0.5.0-alpha.4:
+ resolution: {integrity: sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==}
+ dev: false
+
+ /argparse@2.0.1:
+ resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+ dev: false
+
+ /ast-parents@0.0.1:
+ resolution: {integrity: sha512-XHusKxKz3zoYk1ic8Un640joHbFMhbqneyoZfoKnEGtf2ey9Uh/IdpcQplODdO/kENaMIWsD0nJm4+wX3UNLHA==}
+ dev: false
+
+ /astral-regex@2.0.0:
+ resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==}
+ engines: {node: '>=8'}
+ dev: false
+
+ /balanced-match@1.0.2:
+ resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+ dev: false
+
+ /brace-expansion@2.0.1:
+ resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
+ dependencies:
+ balanced-match: 1.0.2
+ dev: false
+
+ /callsites@3.1.0:
+ resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+ engines: {node: '>=6'}
+ dev: false
+
+ /chalk@2.4.2:
+ resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==}
+ engines: {node: '>=4'}
+ dependencies:
+ ansi-styles: 3.2.1
+ escape-string-regexp: 1.0.5
+ supports-color: 5.5.0
+ dev: false
+
+ /chalk@4.1.2:
+ resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+ engines: {node: '>=10'}
+ dependencies:
+ ansi-styles: 4.3.0
+ supports-color: 7.2.0
+ dev: false
+
+ /color-convert@1.9.3:
+ resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
+ dependencies:
+ color-name: 1.1.3
+ dev: false
+
+ /color-convert@2.0.1:
+ resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+ engines: {node: '>=7.0.0'}
+ dependencies:
+ color-name: 1.1.4
+ dev: false
+
+ /color-name@1.1.3:
+ resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==}
+ dev: false
+
+ /color-name@1.1.4:
+ resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+ dev: false
+
+ /commander@10.0.1:
+ resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==}
+ engines: {node: '>=14'}
+ dev: false
+
+ /cosmiconfig@8.2.0:
+ resolution: {integrity: sha512-3rTMnFJA1tCOPwRxtgF4wd7Ab2qvDbL8jX+3smjIbS4HlZBagTlpERbdN7iAbWlrfxE3M8c27kTwTawQ7st+OQ==}
+ engines: {node: '>=14'}
+ dependencies:
+ import-fresh: 3.3.0
+ js-yaml: 4.1.0
+ parse-json: 5.2.0
+ path-type: 4.0.0
+ dev: false
+
+ /emoji-regex@8.0.0:
+ resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+ dev: false
+
+ /error-ex@1.3.2:
+ resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
+ dependencies:
+ is-arrayish: 0.2.1
+ dev: false
+
+ /escape-string-regexp@1.0.5:
+ resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==}
+ engines: {node: '>=0.8.0'}
+ dev: false
+
+ /fast-deep-equal@3.1.3:
+ resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+ dev: false
+
+ /fast-diff@1.3.0:
+ resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==}
+ dev: false
+
+ /fast-json-stable-stringify@2.1.0:
+ resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+ dev: false
+
+ /fs.realpath@1.0.0:
+ resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
+ dev: false
+
+ /glob@8.1.0:
+ resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==}
+ engines: {node: '>=12'}
+ dependencies:
+ fs.realpath: 1.0.0
+ inflight: 1.0.6
+ inherits: 2.0.4
+ minimatch: 5.1.6
+ once: 1.4.0
+ dev: false
+
+ /has-flag@3.0.0:
+ resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==}
+ engines: {node: '>=4'}
+ dev: false
+
+ /has-flag@4.0.0:
+ resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+ engines: {node: '>=8'}
+ dev: false
+
+ /ignore@5.2.4:
+ resolution: {integrity: sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==}
+ engines: {node: '>= 4'}
+ dev: false
+
+ /import-fresh@3.3.0:
+ resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==}
+ engines: {node: '>=6'}
+ dependencies:
+ parent-module: 1.0.1
+ resolve-from: 4.0.0
+ dev: false
+
+ /inflight@1.0.6:
+ resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
+ dependencies:
+ once: 1.4.0
+ wrappy: 1.0.2
+ dev: false
+
+ /inherits@2.0.4:
+ resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+ dev: false
+
+ /is-arrayish@0.2.1:
+ resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
+ dev: false
+
+ /is-fullwidth-code-point@3.0.0:
+ resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+ engines: {node: '>=8'}
+ dev: false
+
+ /js-tokens@4.0.0:
+ resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+ dev: false
+
+ /js-yaml@4.1.0:
+ resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+ hasBin: true
+ dependencies:
+ argparse: 2.0.1
+ dev: false
+
+ /json-parse-even-better-errors@2.3.1:
+ resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
+ dev: false
+
+ /json-schema-traverse@0.4.1:
+ resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+ dev: false
+
+ /json-schema-traverse@1.0.0:
+ resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
+ dev: false
+
+ /lines-and-columns@1.2.4:
+ resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+ dev: false
+
+ /lodash.truncate@4.4.2:
+ resolution: {integrity: sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==}
+ dev: false
+
+ /lodash@4.17.21:
+ resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
+ dev: false
+
+ /lru-cache@6.0.0:
+ resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
+ engines: {node: '>=10'}
+ dependencies:
+ yallist: 4.0.0
+ dev: false
+
+ /minimatch@5.1.6:
+ resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==}
+ engines: {node: '>=10'}
+ dependencies:
+ brace-expansion: 2.0.1
+ dev: false
+
+ /once@1.4.0:
+ resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+ dependencies:
+ wrappy: 1.0.2
+ dev: false
+
+ /parent-module@1.0.1:
+ resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+ engines: {node: '>=6'}
+ dependencies:
+ callsites: 3.1.0
+ dev: false
+
+ /parse-json@5.2.0:
+ resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+ engines: {node: '>=8'}
+ dependencies:
+ '@babel/code-frame': 7.22.5
+ error-ex: 1.3.2
+ json-parse-even-better-errors: 2.3.1
+ lines-and-columns: 1.2.4
+ dev: false
+
+ /path-type@4.0.0:
+ resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
+ engines: {node: '>=8'}
+ dev: false
+
+ /pluralize@8.0.0:
+ resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
+ engines: {node: '>=4'}
+ dev: false
+
+ /prettier@2.8.8:
+ resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
+ engines: {node: '>=10.13.0'}
+ hasBin: true
+ requiresBuild: true
+ dev: false
+ optional: true
+
+ /prettier@3.0.0:
+ resolution: {integrity: sha512-zBf5eHpwHOGPC47h0zrPyNn+eAEIdEzfywMoYn2XPi0P44Zp0tSq64rq0xAREh4auw2cJZHo9QUob+NqCQky4g==}
+ engines: {node: '>=14'}
+ hasBin: true
+ dev: true
+
+ /punycode@2.3.0:
+ resolution: {integrity: sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==}
+ engines: {node: '>=6'}
+ dev: false
+
+ /require-from-string@2.0.2:
+ resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
+ engines: {node: '>=0.10.0'}
+ dev: false
+
+ /resolve-from@4.0.0:
+ resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+ engines: {node: '>=4'}
+ dev: false
+
+ /semver@7.5.4:
+ resolution: {integrity: sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==}
+ engines: {node: '>=10'}
+ hasBin: true
+ dependencies:
+ lru-cache: 6.0.0
+ dev: false
+
+ /slice-ansi@4.0.0:
+ resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==}
+ engines: {node: '>=10'}
+ dependencies:
+ ansi-styles: 4.3.0
+ astral-regex: 2.0.0
+ is-fullwidth-code-point: 3.0.0
+ dev: false
+
+ /solhint@3.6.2:
+ resolution: {integrity: sha512-85EeLbmkcPwD+3JR7aEMKsVC9YrRSxd4qkXuMzrlf7+z2Eqdfm1wHWq1ffTuo5aDhoZxp2I9yF3QkxZOxOL7aQ==}
+ hasBin: true
+ dependencies:
+ '@solidity-parser/parser': 0.16.1
+ ajv: 6.12.6
+ antlr4: 4.13.0
+ ast-parents: 0.0.1
+ chalk: 4.1.2
+ commander: 10.0.1
+ cosmiconfig: 8.2.0
+ fast-diff: 1.3.0
+ glob: 8.1.0
+ ignore: 5.2.4
+ js-yaml: 4.1.0
+ lodash: 4.17.21
+ pluralize: 8.0.0
+ semver: 7.5.4
+ strip-ansi: 6.0.1
+ table: 6.8.1
+ text-table: 0.2.0
+ optionalDependencies:
+ prettier: 2.8.8
+ dev: false
+
+ /string-width@4.2.3:
+ resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+ engines: {node: '>=8'}
+ dependencies:
+ emoji-regex: 8.0.0
+ is-fullwidth-code-point: 3.0.0
+ strip-ansi: 6.0.1
+ dev: false
+
+ /strip-ansi@6.0.1:
+ resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+ engines: {node: '>=8'}
+ dependencies:
+ ansi-regex: 5.0.1
+ dev: false
+
+ /supports-color@5.5.0:
+ resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
+ engines: {node: '>=4'}
+ dependencies:
+ has-flag: 3.0.0
+ dev: false
+
+ /supports-color@7.2.0:
+ resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+ engines: {node: '>=8'}
+ dependencies:
+ has-flag: 4.0.0
+ dev: false
+
+ /table@6.8.1:
+ resolution: {integrity: sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA==}
+ engines: {node: '>=10.0.0'}
+ dependencies:
+ ajv: 8.12.0
+ lodash.truncate: 4.4.2
+ slice-ansi: 4.0.0
+ string-width: 4.2.3
+ strip-ansi: 6.0.1
+ dev: false
+
+ /text-table@0.2.0:
+ resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==}
+ dev: false
+
+ /uri-js@4.4.1:
+ resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+ dependencies:
+ punycode: 2.3.0
+ dev: false
+
+ /wrappy@1.0.2:
+ resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
+ dev: false
+
+ /yallist@4.0.0:
+ resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
+ dev: false
+
+settings:
+ autoInstallPeers: true
+ excludeLinksFromLockfile: false
diff --git a/remappings.txt b/packages/contracts/remappings.txt
similarity index 92%
rename from remappings.txt
rename to packages/contracts/remappings.txt
index 8b96bd1..f113f1d 100644
--- a/remappings.txt
+++ b/packages/contracts/remappings.txt
@@ -2,6 +2,8 @@
forge-std/=lib/forge-std/src/
@aragon/osx/=lib/osx/packages/contracts/src
datetime/=lib/BokkyPooBahsDateTimeLibrary/contracts
+@ensdomains/ens-contracts/=lib/ens-contracts/
+
@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/
@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
diff --git a/src/Budget.sol b/packages/contracts/src/Budget.sol
similarity index 100%
rename from src/Budget.sol
rename to packages/contracts/src/Budget.sol
diff --git a/src/BudgetSetup.sol b/packages/contracts/src/BudgetSetup.sol
similarity index 100%
rename from src/BudgetSetup.sol
rename to packages/contracts/src/BudgetSetup.sol
diff --git a/packages/contracts/src/Migration.sol b/packages/contracts/src/Migration.sol
new file mode 100644
index 0000000..1a2dc0e
--- /dev/null
+++ b/packages/contracts/src/Migration.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.17;
+
+import { PluginSetupProcessor } from "@aragon/osx/framework/plugin/setup/PluginSetupProcessor.sol";
+
+import { TokenVoting } from "@aragon/osx/plugins/governance/majority-voting/token/TokenVoting.sol";
diff --git a/src/TimeShiftLib.sol b/packages/contracts/src/TimeShiftLib.sol
similarity index 100%
rename from src/TimeShiftLib.sol
rename to packages/contracts/src/TimeShiftLib.sol
diff --git a/packages/contracts/src/metadata/build-metadata.json b/packages/contracts/src/metadata/build-metadata.json
new file mode 100644
index 0000000..6a4b417
--- /dev/null
+++ b/packages/contracts/src/metadata/build-metadata.json
@@ -0,0 +1,20 @@
+{
+ "ui": {},
+ "change": "NA",
+ "pluginSetup": {
+ "prepareInstallation": {
+ "description": "No input is required for the installation.",
+ "inputs": []
+ },
+ "prepareUpdate": {
+ "1": {
+ "description": "No input is required for the update.",
+ "inputs": []
+ }
+ },
+ "prepareUninstallation": {
+ "description": "No input is required for the uninstallation.",
+ "inputs": []
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/metadata/release-metadata.json b/packages/contracts/src/metadata/release-metadata.json
similarity index 98%
rename from src/metadata/release-metadata.json
rename to packages/contracts/src/metadata/release-metadata.json
index 804496a..cbdeba1 100644
--- a/src/metadata/release-metadata.json
+++ b/packages/contracts/src/metadata/release-metadata.json
@@ -2,4 +2,4 @@
"name": "Budget",
"description": "Budget is a Plugin for creating nested allowances on an Aragon OSx DAO",
"images": {}
-}
+}
\ No newline at end of file
diff --git a/test/Budget.t.sol b/packages/contracts/test/Budget.t.sol
similarity index 100%
rename from test/Budget.t.sol
rename to packages/contracts/test/Budget.t.sol
diff --git a/test/TimeShiftLib.t.sol b/packages/contracts/test/TimeShiftLib.t.sol
similarity index 100%
rename from test/TimeShiftLib.t.sol
rename to packages/contracts/test/TimeShiftLib.t.sol
diff --git a/test/base/TestnetTokenFaucet.sol b/packages/contracts/test/base/TestnetTokenFaucet.sol
similarity index 100%
rename from test/base/TestnetTokenFaucet.sol
rename to packages/contracts/test/base/TestnetTokenFaucet.sol
diff --git a/test/base/TribeTest.sol b/packages/contracts/test/base/TribeTest.sol
similarity index 100%
rename from test/base/TribeTest.sol
rename to packages/contracts/test/base/TribeTest.sol
diff --git a/packages/dapp/.eslintrc.json b/packages/dapp/.eslintrc.json
new file mode 100644
index 0000000..bffb357
--- /dev/null
+++ b/packages/dapp/.eslintrc.json
@@ -0,0 +1,3 @@
+{
+ "extends": "next/core-web-vitals"
+}
diff --git a/packages/dapp/.gitignore b/packages/dapp/.gitignore
new file mode 100644
index 0000000..8f322f0
--- /dev/null
+++ b/packages/dapp/.gitignore
@@ -0,0 +1,35 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env*.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
diff --git a/packages/dapp/.vscode/settings.json b/packages/dapp/.vscode/settings.json
new file mode 100644
index 0000000..3662b37
--- /dev/null
+++ b/packages/dapp/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+ "typescript.tsdk": "node_modules/typescript/lib"
+}
\ No newline at end of file
diff --git a/packages/dapp/LICENSE b/packages/dapp/LICENSE
new file mode 100644
index 0000000..7f91f84
--- /dev/null
+++ b/packages/dapp/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Next UI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/dapp/README.md b/packages/dapp/README.md
new file mode 100644
index 0000000..38f323c
--- /dev/null
+++ b/packages/dapp/README.md
@@ -0,0 +1,40 @@
+# Next.js & NextUI Template
+
+This is a template for creating applications using Next.js 13 (app directory) and NextUI (v2).
+
+## Technologies Used
+
+- [Next.js 13](https://nextjs.org/docs/getting-started)
+- [NextUI v2](https://nextui.org/)
+- [Tailwind CSS](https://tailwindcss.com/)
+- [Tailwind Variants](https://tailwind-variants.org)
+- [TypeScript](https://www.typescriptlang.org/)
+- [Framer Motion](https://www.framer.com/motion/)
+- [next-themes](https://github.com/pacocoursey/next-themes)
+
+## How to Use
+
+
+### Use the template with create-next-app
+
+To create a new project based on this template using `create-next-app`, run the following command:
+
+```bash
+npx create-next-app -e https://github.com/nextui-org/next-app-template
+```
+
+### Install dependencies
+
+```bash
+npm install
+```
+
+### Run the development server
+
+```bash
+npm run dev
+```
+
+## License
+
+Licensed under the [MIT license](https://github.com/nextui-org/next-app-template/blob/main/LICENSE).
\ No newline at end of file
diff --git a/packages/dapp/app/about/layout.tsx b/packages/dapp/app/about/layout.tsx
new file mode 100644
index 0000000..d5f6271
--- /dev/null
+++ b/packages/dapp/app/about/layout.tsx
@@ -0,0 +1,13 @@
+export default function AboutLayout({
+ children,
+}: {
+ children: React.ReactNode;
+}) {
+ return (
+
+
+ {children}
+
+
+ );
+}
diff --git a/packages/dapp/app/about/page.tsx b/packages/dapp/app/about/page.tsx
new file mode 100644
index 0000000..596ce4f
--- /dev/null
+++ b/packages/dapp/app/about/page.tsx
@@ -0,0 +1,9 @@
+import { title } from "@/components/primitives";
+
+export default function AboutPage() {
+ return (
+
