├── .vscode └── settings.json ├── frontend-web3-daap ├── public │ ├── robots.txt │ ├── favicon.ico │ ├── logo192.png │ ├── logo512.png │ ├── manifest.json │ └── index.html ├── src │ ├── setupTests.js │ ├── App.test.js │ ├── index.css │ ├── reportWebVitals.js │ ├── index.js │ └── logo.svg ├── .gitignore └── package.json └── backend-smartcontract ├── package.json ├── .gitignore ├── node_modules ├── @openzeppelin │ └── contracts │ │ ├── interfaces │ │ ├── IERC20.sol │ │ ├── IERC721.sol │ │ ├── IERC1155.sol │ │ ├── IERC165.sol │ │ ├── IERC721Receiver.sol │ │ ├── IERC1155Receiver.sol │ │ ├── IERC20Metadata.sol │ │ ├── IERC721Metadata.sol │ │ ├── IERC721Enumerable.sol │ │ ├── IERC1155MetadataURI.sol │ │ ├── IERC2612.sol │ │ ├── IERC3156.sol │ │ ├── IERC5805.sol │ │ ├── IERC5313.sol │ │ ├── IERC6372.sol │ │ ├── IERC2309.sol │ │ ├── draft-IERC7674.sol │ │ ├── IERC1271.sol │ │ ├── IERC1967.sol │ │ ├── IERC1820Implementer.sol │ │ ├── IERC5267.sol │ │ ├── IERC4906.sol │ │ ├── draft-IERC1822.sol │ │ ├── IERC3156FlashBorrower.sol │ │ ├── IERC2981.sol │ │ ├── IERC1363Spender.sol │ │ ├── IERC777Recipient.sol │ │ ├── IERC777Sender.sol │ │ ├── IERC1363Receiver.sol │ │ └── IERC3156FlashLender.sol │ │ ├── build │ │ └── contracts │ │ │ ├── Context.json │ │ │ ├── Proxy.json │ │ │ ├── ReentrancyGuard.json │ │ │ ├── ReentrancyGuardTransient.json │ │ │ ├── IERC5313.json │ │ │ ├── IBeacon.json │ │ │ ├── IERC1822Proxiable.json │ │ │ ├── Bytes.json │ │ │ ├── CAIP2.json │ │ │ ├── Panic.json │ │ │ ├── Arrays.json │ │ │ ├── Base64.json │ │ │ ├── CAIP10.json │ │ │ ├── Heap.json │ │ │ ├── Math.json │ │ │ ├── Time.json │ │ │ ├── P256.json │ │ │ ├── RSA.json │ │ │ ├── BitMaps.json │ │ │ ├── Hashes.json │ │ │ ├── Comparators.json │ │ │ ├── SignedMath.json │ │ │ ├── StorageSlot.json │ │ │ ├── MerkleTree.json │ │ │ ├── TransientSlot.json │ │ │ ├── ERC721Utils.json │ │ │ ├── SlotDerivation.json │ │ │ ├── AuthorityUtils.json │ │ │ ├── ERC1155Utils.json │ │ │ ├── ERC4337Utils.json │ │ │ ├── EnumerableSet.json │ │ │ ├── DoubleEndedQueue.json │ │ │ ├── ERC165Checker.json │ │ │ ├── MessageHashUtils.json │ │ │ ├── SignatureChecker.json │ │ │ ├── ERC165.json │ │ │ ├── IERC165.json │ │ │ ├── Clones.json │ │ │ ├── Create2.json │ │ │ ├── Packing.json │ │ │ ├── Initializable.json │ │ │ ├── Checkpoints.json │ │ │ ├── CircularBuffer.json │ │ │ ├── MerkleProof.json │ │ │ ├── IERC1271.json │ │ │ ├── IERC6372.json │ │ │ ├── IEntryPointNonces.json │ │ │ ├── IERC1820Implementer.json │ │ │ ├── Address.json │ │ │ ├── EnumerableMap.json │ │ │ ├── IAuthority.json │ │ │ ├── IERC1363Spender.json │ │ │ ├── ERC2771Context.json │ │ │ ├── ShortStrings.json │ │ │ ├── Multicall.json │ │ │ ├── IERC2309.json │ │ │ ├── Nonces.json │ │ │ ├── ERC721Holder.json │ │ │ ├── IERC1363Receiver.json │ │ │ ├── IERC721Receiver.json │ │ │ ├── ERC1363Utils.json │ │ │ ├── IERC777Sender.json │ │ │ ├── IERC777Recipient.json │ │ │ ├── IERC3156FlashBorrower.json │ │ │ ├── Strings.json │ │ │ ├── ECDSA.json │ │ │ ├── IERC7579Execution.json │ │ │ ├── IERC7579Module.json │ │ │ ├── IERC1967.json │ │ │ ├── Pausable.json │ │ │ ├── IERC2981.json │ │ │ ├── SafeERC20.json │ │ │ ├── Errors.json │ │ │ ├── IERC5267.json │ │ │ ├── IERC7579AccountConfig.json │ │ │ ├── ERC1967Utils.json │ │ │ ├── NoncesKeyed.json │ │ │ ├── EIP712.json │ │ │ ├── ITransparentUpgradeableProxy.json │ │ │ ├── SafeCast.json │ │ │ ├── Ownable.json │ │ │ ├── IERC2612.json │ │ │ ├── IERC20Permit.json │ │ │ ├── IERC3156FlashLender.json │ │ │ ├── IAccountExecute.json │ │ │ ├── IEntryPointStake.json │ │ │ ├── IERC20Errors.json │ │ │ └── IERC7579Hook.json │ │ ├── utils │ │ ├── Comparators.sol │ │ ├── introspection │ │ │ ├── IERC165.sol │ │ │ └── ERC165.sol │ │ ├── Errors.sol │ │ ├── Context.sol │ │ ├── cryptography │ │ │ └── Hashes.sol │ │ ├── Nonces.sol │ │ ├── Multicall.sol │ │ ├── CAIP2.sol │ │ ├── Panic.sol │ │ ├── structs │ │ │ └── BitMaps.sol │ │ └── ReentrancyGuardTransient.sol │ │ ├── proxy │ │ ├── beacon │ │ │ ├── IBeacon.sol │ │ │ ├── UpgradeableBeacon.sol │ │ │ └── BeaconProxy.sol │ │ ├── ERC1967 │ │ │ └── ERC1967Proxy.sol │ │ └── transparent │ │ │ └── ProxyAdmin.sol │ │ ├── access │ │ ├── manager │ │ │ ├── IAuthority.sol │ │ │ ├── IAccessManaged.sol │ │ │ └── AuthorityUtils.sol │ │ └── extensions │ │ │ └── IAccessControlEnumerable.sol │ │ ├── token │ │ ├── ERC1155 │ │ │ ├── extensions │ │ │ │ ├── IERC1155MetadataURI.sol │ │ │ │ ├── ERC1155Burnable.sol │ │ │ │ ├── ERC1155Pausable.sol │ │ │ │ └── ERC1155URIStorage.sol │ │ │ └── utils │ │ │ │ └── ERC1155Holder.sol │ │ ├── ERC20 │ │ │ └── extensions │ │ │ │ ├── IERC20Metadata.sol │ │ │ │ ├── ERC20Burnable.sol │ │ │ │ ├── ERC20Pausable.sol │ │ │ │ └── ERC20Capped.sol │ │ └── ERC721 │ │ │ ├── utils │ │ │ ├── ERC721Holder.sol │ │ │ └── ERC721Utils.sol │ │ │ ├── extensions │ │ │ ├── IERC721Metadata.sol │ │ │ ├── ERC721Burnable.sol │ │ │ ├── IERC721Enumerable.sol │ │ │ ├── ERC721Royalty.sol │ │ │ ├── ERC721Pausable.sol │ │ │ ├── ERC721Votes.sol │ │ │ └── ERC721URIStorage.sol │ │ │ └── IERC721Receiver.sol │ │ ├── package.json │ │ ├── finance │ │ └── VestingWalletCliff.sol │ │ └── governance │ │ └── extensions │ │ └── GovernorVotes.sol └── .package-lock.json ├── foundry.toml ├── script └── deploy.s.sol ├── package-lock.json ├── .github └── workflows │ └── test.yml ├── README.md └── src └── nftticket-smartcontract.sol /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "git.ignoreLimitWarning": true 3 | } -------------------------------------------------------------------------------- /frontend-web3-daap/public/robots.txt: -------------------------------------------------------------------------------- 1 | # https://www.robotstxt.org/robotstxt.html 2 | User-agent: * 3 | Disallow: 4 | -------------------------------------------------------------------------------- /backend-smartcontract/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "dependencies": { 3 | "@openzeppelin/contracts": "^5.2.0" 4 | } 5 | } 6 | -------------------------------------------------------------------------------- /frontend-web3-daap/public/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Vector-6/NFT-Minting-App/HEAD/frontend-web3-daap/public/favicon.ico -------------------------------------------------------------------------------- /frontend-web3-daap/public/logo192.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Vector-6/NFT-Minting-App/HEAD/frontend-web3-daap/public/logo192.png -------------------------------------------------------------------------------- /frontend-web3-daap/public/logo512.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Vector-6/NFT-Minting-App/HEAD/frontend-web3-daap/public/logo512.png -------------------------------------------------------------------------------- /backend-smartcontract/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiler files 2 | cache/ 3 | out/ 4 | 5 | # Ignores development broadcast logs 6 | !/broadcast 7 | /broadcast/*/31337/ 8 | /broadcast/**/dry-run/ 9 | 10 | # Docs 11 | docs/ 12 | 13 | # Dotenv file 14 | .env 15 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC20.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC20} from "../token/ERC20/IERC20.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC721.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC721.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC721} from "../token/ERC721/IERC721.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC1155.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1155.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC1155} from "../token/ERC1155/IERC1155.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC165.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC165} from "../utils/introspection/IERC165.sol"; 7 | -------------------------------------------------------------------------------- /frontend-web3-daap/src/setupTests.js: -------------------------------------------------------------------------------- 1 | // jest-dom adds custom jest matchers for asserting on DOM nodes. 2 | // allows you to do things like: 3 | // expect(element).toHaveTextContent(/react/i) 4 | // learn more: https://github.com/testing-library/jest-dom 5 | import '@testing-library/jest-dom'; 6 | -------------------------------------------------------------------------------- /frontend-web3-daap/src/App.test.js: -------------------------------------------------------------------------------- 1 | import { render, screen } from '@testing-library/react'; 2 | import App from './App'; 3 | 4 | test('renders learn react link', () => { 5 | render(); 6 | const linkElement = screen.getByText(/learn react/i); 7 | expect(linkElement).toBeInTheDocument(); 8 | }); 9 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC721Receiver.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC721Receiver.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC721Receiver} from "../token/ERC721/IERC721Receiver.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC1155Receiver.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1155Receiver.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC1155Receiver} from "../token/ERC1155/IERC1155Receiver.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC20Metadata.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20Metadata.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC20Metadata} from "../token/ERC20/extensions/IERC20Metadata.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC721Metadata.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC721Metadata.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC721Metadata} from "../token/ERC721/extensions/IERC721Metadata.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC721Enumerable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC721Enumerable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC721Enumerable} from "../token/ERC721/extensions/IERC721Enumerable.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC1155MetadataURI.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1155MetadataURI.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC1155MetadataURI} from "../token/ERC1155/extensions/IERC1155MetadataURI.sol"; 7 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC2612.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC2612.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC20Permit} from "../token/ERC20/extensions/IERC20Permit.sol"; 7 | 8 | interface IERC2612 is IERC20Permit {} 9 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Context.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Context", 4 | "sourceName": "contracts/utils/Context.sol", 5 | "abi": [], 6 | "bytecode": "0x", 7 | "deployedBytecode": "0x", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC3156.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC3156.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC3156FlashBorrower} from "./IERC3156FlashBorrower.sol"; 7 | import {IERC3156FlashLender} from "./IERC3156FlashLender.sol"; 8 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC5805.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5805.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IVotes} from "../governance/utils/IVotes.sol"; 7 | import {IERC6372} from "./IERC6372.sol"; 8 | 9 | interface IERC5805 is IERC6372, IVotes {} 10 | -------------------------------------------------------------------------------- /backend-smartcontract/foundry.toml: -------------------------------------------------------------------------------- 1 | [profile.default] 2 | src = "src" 3 | out = "out" 4 | libs = ["lib"] 5 | remappings=['@openzeppelin=lib/openzeppelin-contracts'] 6 | fs_permissions = [ 7 | { access = "read", path = "./images/" }, 8 | { access = "read", path = "./broadcast" }, 9 | ] 10 | ffi = true 11 | # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options 12 | -------------------------------------------------------------------------------- /frontend-web3-daap/.gitignore: -------------------------------------------------------------------------------- 1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files. 2 | 3 | # dependencies 4 | /node_modules 5 | /.pnp 6 | .pnp.js 7 | 8 | # testing 9 | /coverage 10 | 11 | # production 12 | /build 13 | 14 | # misc 15 | .DS_Store 16 | .env.local 17 | .env.development.local 18 | .env.test.local 19 | .env.production.local 20 | 21 | npm-debug.log* 22 | yarn-debug.log* 23 | yarn-error.log* 24 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Proxy.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Proxy", 4 | "sourceName": "contracts/proxy/Proxy.sol", 5 | "abi": [ 6 | { 7 | "stateMutability": "payable", 8 | "type": "fallback" 9 | } 10 | ], 11 | "bytecode": "0x", 12 | "deployedBytecode": "0x", 13 | "linkReferences": {}, 14 | "deployedLinkReferences": {} 15 | } 16 | -------------------------------------------------------------------------------- /frontend-web3-daap/src/index.css: -------------------------------------------------------------------------------- 1 | body { 2 | margin: 0; 3 | font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 4 | 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', 5 | sans-serif; 6 | -webkit-font-smoothing: antialiased; 7 | -moz-osx-font-smoothing: grayscale; 8 | } 9 | 10 | code { 11 | font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New', 12 | monospace; 13 | } 14 | -------------------------------------------------------------------------------- /frontend-web3-daap/src/reportWebVitals.js: -------------------------------------------------------------------------------- 1 | const reportWebVitals = onPerfEntry => { 2 | if (onPerfEntry && onPerfEntry instanceof Function) { 3 | import('web-vitals').then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => { 4 | getCLS(onPerfEntry); 5 | getFID(onPerfEntry); 6 | getFCP(onPerfEntry); 7 | getLCP(onPerfEntry); 8 | getTTFB(onPerfEntry); 9 | }); 10 | } 11 | }; 12 | 13 | export default reportWebVitals; 14 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ReentrancyGuard.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ReentrancyGuard", 4 | "sourceName": "contracts/utils/ReentrancyGuard.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "ReentrancyGuardReentrantCall", 9 | "type": "error" 10 | } 11 | ], 12 | "bytecode": "0x", 13 | "deployedBytecode": "0x", 14 | "linkReferences": {}, 15 | "deployedLinkReferences": {} 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/script/deploy.s.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | import "forge-std/Script.sol"; 5 | import "../src/nft.sol"; 6 | 7 | contract DeployTicketNFT is Script { 8 | function run() external { 9 | vm.startBroadcast(); 10 | 11 | 12 | TicketNFT ticketNFT = new TicketNFT("NFTTICKET", "NFTT"); 13 | 14 | 15 | console.log("TicketNFT deployed at:", address(ticketNFT)); 16 | 17 | 18 | vm.stopBroadcast(); 19 | } 20 | } -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/.package-lock.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "backend-smartcontract", 3 | "lockfileVersion": 3, 4 | "requires": true, 5 | "packages": { 6 | "node_modules/@openzeppelin/contracts": { 7 | "version": "5.2.0", 8 | "resolved": "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-5.2.0.tgz", 9 | "integrity": "sha512-bxjNie5z89W1Ea0NZLZluFh8PrFNn9DH8DQlujEok2yjsOlraUPKID5p1Wk3qdNbf6XkQ1Os2RvfiHrrXLHWKA==", 10 | "license": "MIT" 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ReentrancyGuardTransient.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ReentrancyGuardTransient", 4 | "sourceName": "contracts/utils/ReentrancyGuardTransient.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "ReentrancyGuardReentrantCall", 9 | "type": "error" 10 | } 11 | ], 12 | "bytecode": "0x", 13 | "deployedBytecode": "0x", 14 | "linkReferences": {}, 15 | "deployedLinkReferences": {} 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC5313.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5313.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Interface for the Light Contract Ownership Standard. 8 | * 9 | * A standardized minimal interface required to identify an account that controls a contract 10 | */ 11 | interface IERC5313 { 12 | /** 13 | * @dev Gets the address of the owner. 14 | */ 15 | function owner() external view returns (address); 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/Comparators.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (utils/Comparators.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Provides a set of functions to compare values. 8 | * 9 | * _Available since v5.1._ 10 | */ 11 | library Comparators { 12 | function lt(uint256 a, uint256 b) internal pure returns (bool) { 13 | return a < b; 14 | } 15 | 16 | function gt(uint256 a, uint256 b) internal pure returns (bool) { 17 | return a > b; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/proxy/beacon/IBeacon.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev This is the interface that {BeaconProxy} expects of its beacon. 8 | */ 9 | interface IBeacon { 10 | /** 11 | * @dev Must return an address that can be used as a delegate call target. 12 | * 13 | * {UpgradeableBeacon} will check that this address is a contract. 14 | */ 15 | function implementation() external view returns (address); 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/access/manager/IAuthority.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAuthority.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Standard interface for permissioning originally defined in Dappsys. 8 | */ 9 | interface IAuthority { 10 | /** 11 | * @dev Returns true if the caller can invoke on a target the function identified by a function selector. 12 | */ 13 | function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed); 14 | } 15 | -------------------------------------------------------------------------------- /backend-smartcontract/package-lock.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "backend-smartcontract", 3 | "lockfileVersion": 3, 4 | "requires": true, 5 | "packages": { 6 | "": { 7 | "dependencies": { 8 | "@openzeppelin/contracts": "^5.2.0" 9 | } 10 | }, 11 | "node_modules/@openzeppelin/contracts": { 12 | "version": "5.2.0", 13 | "resolved": "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-5.2.0.tgz", 14 | "integrity": "sha512-bxjNie5z89W1Ea0NZLZluFh8PrFNn9DH8DQlujEok2yjsOlraUPKID5p1Wk3qdNbf6XkQ1Os2RvfiHrrXLHWKA==", 15 | "license": "MIT" 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /frontend-web3-daap/src/index.js: -------------------------------------------------------------------------------- 1 | import React from 'react'; 2 | import ReactDOM from 'react-dom/client'; 3 | import './index.css'; 4 | import App from './App'; 5 | import reportWebVitals from './reportWebVitals'; 6 | 7 | const root = ReactDOM.createRoot(document.getElementById('root')); 8 | root.render( 9 | 10 | 11 | 12 | ); 13 | 14 | // If you want to start measuring performance in your app, pass a function 15 | // to log results (for example: reportWebVitals(console.log)) 16 | // or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals 17 | reportWebVitals(); 18 | -------------------------------------------------------------------------------- /frontend-web3-daap/public/manifest.json: -------------------------------------------------------------------------------- 1 | { 2 | "short_name": "React App", 3 | "name": "Create React App Sample", 4 | "icons": [ 5 | { 6 | "src": "favicon.ico", 7 | "sizes": "64x64 32x32 24x24 16x16", 8 | "type": "image/x-icon" 9 | }, 10 | { 11 | "src": "logo192.png", 12 | "type": "image/png", 13 | "sizes": "192x192" 14 | }, 15 | { 16 | "src": "logo512.png", 17 | "type": "image/png", 18 | "sizes": "512x512" 19 | } 20 | ], 21 | "start_url": ".", 22 | "display": "standalone", 23 | "theme_color": "#000000", 24 | "background_color": "#ffffff" 25 | } 26 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC6372.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC6372.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | interface IERC6372 { 7 | /** 8 | * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting). 9 | */ 10 | function clock() external view returns (uint48); 11 | 12 | /** 13 | * @dev Description of the clock 14 | */ 15 | // solhint-disable-next-line func-name-mixedcase 16 | function CLOCK_MODE() external view returns (string memory); 17 | } 18 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC5313.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC5313", 4 | "sourceName": "contracts/interfaces/IERC5313.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "owner", 9 | "outputs": [ 10 | { 11 | "internalType": "address", 12 | "name": "", 13 | "type": "address" 14 | } 15 | ], 16 | "stateMutability": "view", 17 | "type": "function" 18 | } 19 | ], 20 | "bytecode": "0x", 21 | "deployedBytecode": "0x", 22 | "linkReferences": {}, 23 | "deployedLinkReferences": {} 24 | } 25 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IBeacon.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IBeacon", 4 | "sourceName": "contracts/proxy/beacon/IBeacon.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "implementation", 9 | "outputs": [ 10 | { 11 | "internalType": "address", 12 | "name": "", 13 | "type": "address" 14 | } 15 | ], 16 | "stateMutability": "view", 17 | "type": "function" 18 | } 19 | ], 20 | "bytecode": "0x", 21 | "deployedBytecode": "0x", 22 | "linkReferences": {}, 23 | "deployedLinkReferences": {} 24 | } 25 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC2309.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC2309.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev ERC-2309: ERC-721 Consecutive Transfer Extension. 8 | */ 9 | interface IERC2309 { 10 | /** 11 | * @dev Emitted when the tokens from `fromTokenId` to `toTokenId` are transferred from `fromAddress` to `toAddress`. 12 | */ 13 | event ConsecutiveTransfer( 14 | uint256 indexed fromTokenId, 15 | uint256 toTokenId, 16 | address indexed fromAddress, 17 | address indexed toAddress 18 | ); 19 | } 20 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC1822Proxiable.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC1822Proxiable", 4 | "sourceName": "contracts/interfaces/draft-IERC1822.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "proxiableUUID", 9 | "outputs": [ 10 | { 11 | "internalType": "bytes32", 12 | "name": "", 13 | "type": "bytes32" 14 | } 15 | ], 16 | "stateMutability": "view", 17 | "type": "function" 18 | } 19 | ], 20 | "bytecode": "0x", 21 | "deployedBytecode": "0x", 22 | "linkReferences": {}, 23 | "deployedLinkReferences": {} 24 | } 25 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/draft-IERC7674.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC7674.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC20} from "./IERC20.sol"; 7 | 8 | /** 9 | * @dev Temporary Approval Extension for ERC-20 (https://github.com/ethereum/ERCs/pull/358[ERC-7674]) 10 | */ 11 | interface IERC7674 is IERC20 { 12 | /** 13 | * @dev Set the temporary allowance, allowing `spender` to withdraw (within the same transaction) assets 14 | * held by the caller. 15 | */ 16 | function temporaryApprove(address spender, uint256 value) external returns (bool success); 17 | } 18 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Bytes.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Bytes", 4 | "sourceName": "contracts/utils/Bytes.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212202386e77e63f85208ef720e5650f94307dd1637a9dc5ccb381c2cb332836f741764736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212202386e77e63f85208ef720e5650f94307dd1637a9dc5ccb381c2cb332836f741764736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/CAIP2.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "CAIP2", 4 | "sourceName": "contracts/utils/CAIP2.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212209c0a38709b2c3fda85c00a845a72fbde2005b668a5326fd809b0959ec762dad664736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212209c0a38709b2c3fda85c00a845a72fbde2005b668a5326fd809b0959ec762dad664736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Panic.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Panic", 4 | "sourceName": "contracts/utils/Panic.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212206a78456eefd7fb4c37aaea7305d7835fd2ac43f1cd41349b1575d241d6215c7764736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212206a78456eefd7fb4c37aaea7305d7835fd2ac43f1cd41349b1575d241d6215c7764736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Arrays.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Arrays", 4 | "sourceName": "contracts/utils/Arrays.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220e2a43b305370637c0e72a712b97be4e82ddabe0a05b5a79db89595c8f384825b64736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220e2a43b305370637c0e72a712b97be4e82ddabe0a05b5a79db89595c8f384825b64736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Base64.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Base64", 4 | "sourceName": "contracts/utils/Base64.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122059ee73e8b5e0210337b4c01c3d1c3ad448e5d23a44aa6ffc8d87dae6ae184e9064736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122059ee73e8b5e0210337b4c01c3d1c3ad448e5d23a44aa6ffc8d87dae6ae184e9064736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/CAIP10.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "CAIP10", 4 | "sourceName": "contracts/utils/CAIP10.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122058b0727f2e226e087349ee2d25316c75a667d122e886ee90b8d0749b62d4149864736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122058b0727f2e226e087349ee2d25316c75a667d122e886ee90b8d0749b62d4149864736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Heap.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Heap", 4 | "sourceName": "contracts/utils/structs/Heap.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220d53a5022117a5512a350e83c6a4046779687749a2ee1e389044062b3da4d8fc864736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220d53a5022117a5512a350e83c6a4046779687749a2ee1e389044062b3da4d8fc864736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Math.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Math", 4 | "sourceName": "contracts/utils/math/Math.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220bb340385fc65bee4ab175a10b44feff67f2c919e55a3d5c7ad6490a3263923ec64736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220bb340385fc65bee4ab175a10b44feff67f2c919e55a3d5c7ad6490a3263923ec64736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Time.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Time", 4 | "sourceName": "contracts/utils/types/Time.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220a2f1f5967228e8edc2cc6f7be3e94934b8bae7ac5593131a485ff56647a7b51464736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220a2f1f5967228e8edc2cc6f7be3e94934b8bae7ac5593131a485ff56647a7b51464736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/P256.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "P256", 4 | "sourceName": "contracts/utils/cryptography/P256.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212203bc86b67823aae81d5f0eb3719880a1b5cfb6f9f1ebd4e23f81e411b2771ab5664736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212203bc86b67823aae81d5f0eb3719880a1b5cfb6f9f1ebd4e23f81e411b2771ab5664736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/RSA.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "RSA", 4 | "sourceName": "contracts/utils/cryptography/RSA.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220978755ab25f579f71ce2295f5fe583320f807e52aac70f960ce40117a27d8c8e64736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220978755ab25f579f71ce2295f5fe583320f807e52aac70f960ce40117a27d8c8e64736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/BitMaps.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "BitMaps", 4 | "sourceName": "contracts/utils/structs/BitMaps.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220da3993ad2160ca1a592a7d641890dfb983a7b0cb2a7a6508daf03a4ec48e18b664736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220da3993ad2160ca1a592a7d641890dfb983a7b0cb2a7a6508daf03a4ec48e18b664736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Hashes.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Hashes", 4 | "sourceName": "contracts/utils/cryptography/Hashes.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220b7a9039e2da0100ed88948306845427801d2e6687bc4f3352c7534c97b0a6b2064736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220b7a9039e2da0100ed88948306845427801d2e6687bc4f3352c7534c97b0a6b2064736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Comparators.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Comparators", 4 | "sourceName": "contracts/utils/Comparators.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212201460424865a204a0081e856e80107052584b78f95066e73c995bdd6e54c7237164736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212201460424865a204a0081e856e80107052584b78f95066e73c995bdd6e54c7237164736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/SignedMath.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "SignedMath", 4 | "sourceName": "contracts/utils/math/SignedMath.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220cbe3415c69300b6722c740e5094619ccda5fd3ea4ae872968fea3cfcb1665e1c64736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220cbe3415c69300b6722c740e5094619ccda5fd3ea4ae872968fea3cfcb1665e1c64736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/StorageSlot.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "StorageSlot", 4 | "sourceName": "contracts/utils/StorageSlot.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212201aa70b262fdef53d4d5d15f75ab35d72f66beea19586afb867d1e4db1df6383564736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212201aa70b262fdef53d4d5d15f75ab35d72f66beea19586afb867d1e4db1df6383564736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC1271.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1271.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Interface of the ERC-1271 standard signature validation method for 8 | * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271]. 9 | */ 10 | interface IERC1271 { 11 | /** 12 | * @dev Should return whether the signature provided is valid for the provided data 13 | * @param hash Hash of the data to be signed 14 | * @param signature Signature byte array associated with _data 15 | */ 16 | function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue); 17 | } 18 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/MerkleTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "MerkleTree", 4 | "sourceName": "contracts/utils/structs/MerkleTree.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220dfbd5bd11675d488b6f85bbdbe22a06f20c4fbdaf8015e496a77a93ec226ff4464736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220dfbd5bd11675d488b6f85bbdbe22a06f20c4fbdaf8015e496a77a93ec226ff4464736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/TransientSlot.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "TransientSlot", 4 | "sourceName": "contracts/utils/TransientSlot.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122067559b02518773e24a5fa6866418a8edf51bb1a3c7d8f25a62a45f81f7a4d57e64736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122067559b02518773e24a5fa6866418a8edf51bb1a3c7d8f25a62a45f81f7a4d57e64736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC721Utils.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC721Utils", 4 | "sourceName": "contracts/token/ERC721/utils/ERC721Utils.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122028b05ff2bdd4bdabd5fa29d3bf2de4a62007fb06b6147242aec4cbb4d66a8aa964736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122028b05ff2bdd4bdabd5fa29d3bf2de4a62007fb06b6147242aec4cbb4d66a8aa964736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/SlotDerivation.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "SlotDerivation", 4 | "sourceName": "contracts/utils/SlotDerivation.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220c412ee086e9d4b6f68fa5027702ad99e54ca17171f0708427844384cc53cab8664736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220c412ee086e9d4b6f68fa5027702ad99e54ca17171f0708427844384cc53cab8664736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/AuthorityUtils.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "AuthorityUtils", 4 | "sourceName": "contracts/access/manager/AuthorityUtils.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220afa71a02bee64c1b40db7b593038b137c8028fee4e73cc4cb6c6c3502850168364736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220afa71a02bee64c1b40db7b593038b137c8028fee4e73cc4cb6c6c3502850168364736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC1155Utils.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC1155Utils", 4 | "sourceName": "contracts/token/ERC1155/utils/ERC1155Utils.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212205982cb5fcd8921378f2a70b48f3782a114729f42080308828de367cacb7e045564736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212205982cb5fcd8921378f2a70b48f3782a114729f42080308828de367cacb7e045564736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC4337Utils.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC4337Utils", 4 | "sourceName": "contracts/account/utils/draft-ERC4337Utils.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220317a53a71917ef310a1e8cf87bea1b3ea2040c198188e9f573ef10765084c6ef64736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220317a53a71917ef310a1e8cf87bea1b3ea2040c198188e9f573ef10765084c6ef64736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/EnumerableSet.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "EnumerableSet", 4 | "sourceName": "contracts/utils/structs/EnumerableSet.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220465cbbc3ad6dfa00cc43e759da8ac226700e699948a37b4defb346b670ebafbb64736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220465cbbc3ad6dfa00cc43e759da8ac226700e699948a37b4defb346b670ebafbb64736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/DoubleEndedQueue.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "DoubleEndedQueue", 4 | "sourceName": "contracts/utils/structs/DoubleEndedQueue.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220c40900afaa34ea372a4e6a388f4f274cf97299d3443950eb1d47939b6c50bd6464736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220c40900afaa34ea372a4e6a388f4f274cf97299d3443950eb1d47939b6c50bd6464736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC165Checker.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC165Checker", 4 | "sourceName": "contracts/utils/introspection/ERC165Checker.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220a79100f81433811ae317ec9da94c09560486f3f0a0e710ab0b0529b58616717c64736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220a79100f81433811ae317ec9da94c09560486f3f0a0e710ab0b0529b58616717c64736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC1967.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1967.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC. 8 | */ 9 | interface IERC1967 { 10 | /** 11 | * @dev Emitted when the implementation is upgraded. 12 | */ 13 | event Upgraded(address indexed implementation); 14 | 15 | /** 16 | * @dev Emitted when the admin account has changed. 17 | */ 18 | event AdminChanged(address previousAdmin, address newAdmin); 19 | 20 | /** 21 | * @dev Emitted when the beacon is changed. 22 | */ 23 | event BeaconUpgraded(address indexed beacon); 24 | } 25 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/MessageHashUtils.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "MessageHashUtils", 4 | "sourceName": "contracts/utils/cryptography/MessageHashUtils.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212205c7522b6f862a648659db966003a8e0c4ed1a62cb2f7e41c581df26dfb00482764736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212205c7522b6f862a648659db966003a8e0c4ed1a62cb2f7e41c581df26dfb00482764736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/SignatureChecker.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "SignatureChecker", 4 | "sourceName": "contracts/utils/cryptography/SignatureChecker.sol", 5 | "abi": [], 6 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212209d1f82534a00f043167a9e180fa0f15feb39fa3b68000ce938a647dbfa254f2464736f6c63430008180033", 7 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212209d1f82534a00f043167a9e180fa0f15feb39fa3b68000ce938a647dbfa254f2464736f6c63430008180033", 8 | "linkReferences": {}, 9 | "deployedLinkReferences": {} 10 | } 11 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC165.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC165", 4 | "sourceName": "contracts/utils/introspection/ERC165.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "bytes4", 10 | "name": "interfaceId", 11 | "type": "bytes4" 12 | } 13 | ], 14 | "name": "supportsInterface", 15 | "outputs": [ 16 | { 17 | "internalType": "bool", 18 | "name": "", 19 | "type": "bool" 20 | } 21 | ], 22 | "stateMutability": "view", 23 | "type": "function" 24 | } 25 | ], 26 | "bytecode": "0x", 27 | "deployedBytecode": "0x", 28 | "linkReferences": {}, 29 | "deployedLinkReferences": {} 30 | } 31 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC165.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC165", 4 | "sourceName": "contracts/utils/introspection/IERC165.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "bytes4", 10 | "name": "interfaceId", 11 | "type": "bytes4" 12 | } 13 | ], 14 | "name": "supportsInterface", 15 | "outputs": [ 16 | { 17 | "internalType": "bool", 18 | "name": "", 19 | "type": "bool" 20 | } 21 | ], 22 | "stateMutability": "view", 23 | "type": "function" 24 | } 25 | ], 26 | "bytecode": "0x", 27 | "deployedBytecode": "0x", 28 | "linkReferences": {}, 29 | "deployedLinkReferences": {} 30 | } 31 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC1155} from "../IERC1155.sol"; 7 | 8 | /** 9 | * @dev Interface of the optional ERC1155MetadataExtension interface, as defined 10 | * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[ERC]. 11 | */ 12 | interface IERC1155MetadataURI is IERC1155 { 13 | /** 14 | * @dev Returns the URI for token type `id`. 15 | * 16 | * If the `\{id\}` substring is present in the URI, it must be replaced by 17 | * clients with the actual token type ID. 18 | */ 19 | function uri(uint256 id) external view returns (string memory); 20 | } 21 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC20} from "../IERC20.sol"; 7 | 8 | /** 9 | * @dev Interface for the optional metadata functions from the ERC-20 standard. 10 | */ 11 | interface IERC20Metadata is IERC20 { 12 | /** 13 | * @dev Returns the name of the token. 14 | */ 15 | function name() external view returns (string memory); 16 | 17 | /** 18 | * @dev Returns the symbol of the token. 19 | */ 20 | function symbol() external view returns (string memory); 21 | 22 | /** 23 | * @dev Returns the decimals places of the token. 24 | */ 25 | function decimals() external view returns (uint8); 26 | } 27 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Clones.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Clones", 4 | "sourceName": "contracts/proxy/Clones.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "CloneArgumentsTooLong", 9 | "type": "error" 10 | } 11 | ], 12 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220e94b4db85bde540e4f16e0a985698ce102c87b5b83b05adf9117c46a6defa0f164736f6c63430008180033", 13 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220e94b4db85bde540e4f16e0a985698ce102c87b5b83b05adf9117c46a6defa0f164736f6c63430008180033", 14 | "linkReferences": {}, 15 | "deployedLinkReferences": {} 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Create2.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Create2", 4 | "sourceName": "contracts/utils/Create2.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "Create2EmptyBytecode", 9 | "type": "error" 10 | } 11 | ], 12 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122075fd4ae0362763b90f9fd508910184655855a7cc7f610274115c0e03eb70b02d64736f6c63430008180033", 13 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122075fd4ae0362763b90f9fd508910184655855a7cc7f610274115c0e03eb70b02d64736f6c63430008180033", 14 | "linkReferences": {}, 15 | "deployedLinkReferences": {} 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Packing.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Packing", 4 | "sourceName": "contracts/utils/Packing.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "OutOfRangeAccess", 9 | "type": "error" 10 | } 11 | ], 12 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122077da9cb8a863876bb8fd1cf8e173eb17774372c7c57a1da31e02e76faf8896f064736f6c63430008180033", 13 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122077da9cb8a863876bb8fd1cf8e173eb17774372c7c57a1da31e02e76faf8896f064736f6c63430008180033", 14 | "linkReferences": {}, 15 | "deployedLinkReferences": {} 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Initializable.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Initializable", 4 | "sourceName": "contracts/proxy/utils/Initializable.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "InvalidInitialization", 9 | "type": "error" 10 | }, 11 | { 12 | "inputs": [], 13 | "name": "NotInitializing", 14 | "type": "error" 15 | }, 16 | { 17 | "anonymous": false, 18 | "inputs": [ 19 | { 20 | "indexed": false, 21 | "internalType": "uint64", 22 | "name": "version", 23 | "type": "uint64" 24 | } 25 | ], 26 | "name": "Initialized", 27 | "type": "event" 28 | } 29 | ], 30 | "bytecode": "0x", 31 | "deployedBytecode": "0x", 32 | "linkReferences": {}, 33 | "deployedLinkReferences": {} 34 | } 35 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Checkpoints.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Checkpoints", 4 | "sourceName": "contracts/utils/structs/Checkpoints.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "CheckpointUnorderedInsertion", 9 | "type": "error" 10 | } 11 | ], 12 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212202e2e3bfb8b8a0549a6f30098459c9752b38969bc026a73cb7029d4b1dca7f62264736f6c63430008180033", 13 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212202e2e3bfb8b8a0549a6f30098459c9752b38969bc026a73cb7029d4b1dca7f62264736f6c63430008180033", 14 | "linkReferences": {}, 15 | "deployedLinkReferences": {} 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/CircularBuffer.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "CircularBuffer", 4 | "sourceName": "contracts/utils/structs/CircularBuffer.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "InvalidBufferSize", 9 | "type": "error" 10 | } 11 | ], 12 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212200bff15853473c498ae173fe23a0e2355f5e3241dee005d1b5ebdd54c2c5be7c864736f6c63430008180033", 13 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212200bff15853473c498ae173fe23a0e2355f5e3241dee005d1b5ebdd54c2c5be7c864736f6c63430008180033", 14 | "linkReferences": {}, 15 | "deployedLinkReferences": {} 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC1820Implementer.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1820Implementer.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Interface for an ERC-1820 implementer, as defined in the 8 | * https://eips.ethereum.org/EIPS/eip-1820#interface-implementation-erc1820implementerinterface[ERC]. 9 | * Used by contracts that will be registered as implementers in the 10 | * {IERC1820Registry}. 11 | */ 12 | interface IERC1820Implementer { 13 | /** 14 | * @dev Returns a special value (`ERC1820_ACCEPT_MAGIC`) if this contract 15 | * implements `interfaceHash` for `account`. 16 | * 17 | * See {IERC1820Registry-setInterfaceImplementer}. 18 | */ 19 | function canImplementInterfaceForAddress(bytes32 interfaceHash, address account) external view returns (bytes32); 20 | } 21 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC5267.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | interface IERC5267 { 7 | /** 8 | * @dev MAY be emitted to signal that the domain could have changed. 9 | */ 10 | event EIP712DomainChanged(); 11 | 12 | /** 13 | * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712 14 | * signature. 15 | */ 16 | function eip712Domain() 17 | external 18 | view 19 | returns ( 20 | bytes1 fields, 21 | string memory name, 22 | string memory version, 23 | uint256 chainId, 24 | address verifyingContract, 25 | bytes32 salt, 26 | uint256[] memory extensions 27 | ); 28 | } 29 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/MerkleProof.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "MerkleProof", 4 | "sourceName": "contracts/utils/cryptography/MerkleProof.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "MerkleProofInvalidMultiproof", 9 | "type": "error" 10 | } 11 | ], 12 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212202a578e0ee33df5da5254baedcc290f35f789cc06faa798a3b7b1c1c76cd4c27c64736f6c63430008180033", 13 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212202a578e0ee33df5da5254baedcc290f35f789cc06faa798a3b7b1c1c76cd4c27c64736f6c63430008180033", 14 | "linkReferences": {}, 15 | "deployedLinkReferences": {} 16 | } 17 | -------------------------------------------------------------------------------- /backend-smartcontract/.github/workflows/test.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: 4 | push: 5 | pull_request: 6 | workflow_dispatch: 7 | 8 | env: 9 | FOUNDRY_PROFILE: ci 10 | 11 | jobs: 12 | check: 13 | strategy: 14 | fail-fast: true 15 | 16 | name: Foundry project 17 | runs-on: ubuntu-latest 18 | steps: 19 | - uses: actions/checkout@v4 20 | with: 21 | submodules: recursive 22 | 23 | - name: Install Foundry 24 | uses: foundry-rs/foundry-toolchain@v1 25 | 26 | - name: Show Forge version 27 | run: | 28 | forge --version 29 | 30 | - name: Run Forge fmt 31 | run: | 32 | forge fmt --check 33 | id: fmt 34 | 35 | - name: Run Forge build 36 | run: | 37 | forge build --sizes 38 | id: build 39 | 40 | - name: Run Forge tests 41 | run: | 42 | forge test -vvv 43 | id: test 44 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC1271.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC1271", 4 | "sourceName": "contracts/interfaces/IERC1271.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "bytes32", 10 | "name": "hash", 11 | "type": "bytes32" 12 | }, 13 | { 14 | "internalType": "bytes", 15 | "name": "signature", 16 | "type": "bytes" 17 | } 18 | ], 19 | "name": "isValidSignature", 20 | "outputs": [ 21 | { 22 | "internalType": "bytes4", 23 | "name": "magicValue", 24 | "type": "bytes4" 25 | } 26 | ], 27 | "stateMutability": "view", 28 | "type": "function" 29 | } 30 | ], 31 | "bytecode": "0x", 32 | "deployedBytecode": "0x", 33 | "linkReferences": {}, 34 | "deployedLinkReferences": {} 35 | } 36 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC6372.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC6372", 4 | "sourceName": "contracts/interfaces/IERC6372.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "CLOCK_MODE", 9 | "outputs": [ 10 | { 11 | "internalType": "string", 12 | "name": "", 13 | "type": "string" 14 | } 15 | ], 16 | "stateMutability": "view", 17 | "type": "function" 18 | }, 19 | { 20 | "inputs": [], 21 | "name": "clock", 22 | "outputs": [ 23 | { 24 | "internalType": "uint48", 25 | "name": "", 26 | "type": "uint48" 27 | } 28 | ], 29 | "stateMutability": "view", 30 | "type": "function" 31 | } 32 | ], 33 | "bytecode": "0x", 34 | "deployedBytecode": "0x", 35 | "linkReferences": {}, 36 | "deployedLinkReferences": {} 37 | } 38 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/utils/ERC721Holder.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC721Receiver} from "../IERC721Receiver.sol"; 7 | 8 | /** 9 | * @dev Implementation of the {IERC721Receiver} interface. 10 | * 11 | * Accepts all token transfers. 12 | * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or 13 | * {IERC721-setApprovalForAll}. 14 | */ 15 | abstract contract ERC721Holder is IERC721Receiver { 16 | /** 17 | * @dev See {IERC721Receiver-onERC721Received}. 18 | * 19 | * Always returns `IERC721Receiver.onERC721Received.selector`. 20 | */ 21 | function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) { 22 | return this.onERC721Received.selector; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IEntryPointNonces.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IEntryPointNonces", 4 | "sourceName": "contracts/interfaces/draft-IERC4337.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "sender", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "uint192", 15 | "name": "key", 16 | "type": "uint192" 17 | } 18 | ], 19 | "name": "getNonce", 20 | "outputs": [ 21 | { 22 | "internalType": "uint256", 23 | "name": "nonce", 24 | "type": "uint256" 25 | } 26 | ], 27 | "stateMutability": "view", 28 | "type": "function" 29 | } 30 | ], 31 | "bytecode": "0x", 32 | "deployedBytecode": "0x", 33 | "linkReferences": {}, 34 | "deployedLinkReferences": {} 35 | } 36 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "@openzeppelin/contracts", 3 | "description": "Secure Smart Contract library for Solidity", 4 | "version": "5.2.0", 5 | "files": [ 6 | "**/*.sol", 7 | "/build/contracts/*.json", 8 | "!/mocks/**/*" 9 | ], 10 | "scripts": { 11 | "prepack": "bash ../scripts/prepack.sh", 12 | "prepare-docs": "cd ..; npm run prepare-docs" 13 | }, 14 | "repository": { 15 | "type": "git", 16 | "url": "https://github.com/OpenZeppelin/openzeppelin-contracts.git" 17 | }, 18 | "keywords": [ 19 | "solidity", 20 | "ethereum", 21 | "smart", 22 | "contracts", 23 | "security", 24 | "zeppelin" 25 | ], 26 | "author": "OpenZeppelin Community ", 27 | "license": "MIT", 28 | "bugs": { 29 | "url": "https://github.com/OpenZeppelin/openzeppelin-contracts/issues" 30 | }, 31 | "homepage": "https://openzeppelin.com/contracts/" 32 | } 33 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC4906.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC4906.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC165} from "./IERC165.sol"; 7 | import {IERC721} from "./IERC721.sol"; 8 | 9 | /// @title ERC-721 Metadata Update Extension 10 | interface IERC4906 is IERC165, IERC721 { 11 | /// @dev This event emits when the metadata of a token is changed. 12 | /// So that the third-party platforms such as NFT market could 13 | /// timely update the images and related attributes of the NFT. 14 | event MetadataUpdate(uint256 _tokenId); 15 | 16 | /// @dev This event emits when the metadata of a range of tokens is changed. 17 | /// So that the third-party platforms such as NFT market could 18 | /// timely update the images and related attributes of the NFTs. 19 | event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId); 20 | } 21 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC721} from "../IERC721.sol"; 7 | 8 | /** 9 | * @title ERC-721 Non-Fungible Token Standard, optional metadata extension 10 | * @dev See https://eips.ethereum.org/EIPS/eip-721 11 | */ 12 | interface IERC721Metadata is IERC721 { 13 | /** 14 | * @dev Returns the token collection name. 15 | */ 16 | function name() external view returns (string memory); 17 | 18 | /** 19 | * @dev Returns the token collection symbol. 20 | */ 21 | function symbol() external view returns (string memory); 22 | 23 | /** 24 | * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. 25 | */ 26 | function tokenURI(uint256 tokenId) external view returns (string memory); 27 | } 28 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC1820Implementer.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC1820Implementer", 4 | "sourceName": "contracts/interfaces/IERC1820Implementer.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "bytes32", 10 | "name": "interfaceHash", 11 | "type": "bytes32" 12 | }, 13 | { 14 | "internalType": "address", 15 | "name": "account", 16 | "type": "address" 17 | } 18 | ], 19 | "name": "canImplementInterfaceForAddress", 20 | "outputs": [ 21 | { 22 | "internalType": "bytes32", 23 | "name": "", 24 | "type": "bytes32" 25 | } 26 | ], 27 | "stateMutability": "view", 28 | "type": "function" 29 | } 30 | ], 31 | "bytecode": "0x", 32 | "deployedBytecode": "0x", 33 | "linkReferences": {}, 34 | "deployedLinkReferences": {} 35 | } 36 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/draft-IERC1822.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC1822.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified 8 | * proxy whose upgrades are fully controlled by the current implementation. 9 | */ 10 | interface IERC1822Proxiable { 11 | /** 12 | * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation 13 | * address. 14 | * 15 | * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks 16 | * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this 17 | * function revert if invoked through a proxy. 18 | */ 19 | function proxiableUUID() external view returns (bytes32); 20 | } 21 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Address.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Address", 4 | "sourceName": "contracts/utils/Address.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "target", 11 | "type": "address" 12 | } 13 | ], 14 | "name": "AddressEmptyCode", 15 | "type": "error" 16 | } 17 | ], 18 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220f6d1fb5ab529d77416d8f752dcc59529daa813a8f0e7d2ee1aea5cfb1389e5c664736f6c63430008180033", 19 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220f6d1fb5ab529d77416d8f752dcc59529daa813a8f0e7d2ee1aea5cfb1389e5c664736f6c63430008180033", 20 | "linkReferences": {}, 21 | "deployedLinkReferences": {} 22 | } 23 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Interface of the ERC-165 standard, as defined in the 8 | * https://eips.ethereum.org/EIPS/eip-165[ERC]. 9 | * 10 | * Implementers can declare support of contract interfaces, which can then be 11 | * queried by others ({ERC165Checker}). 12 | * 13 | * For an implementation, see {ERC165}. 14 | */ 15 | interface IERC165 { 16 | /** 17 | * @dev Returns true if this contract implements the interface defined by 18 | * `interfaceId`. See the corresponding 19 | * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] 20 | * to learn more about how these ids are created. 21 | * 22 | * This function call must use less than 30 000 gas. 23 | */ 24 | function supportsInterface(bytes4 interfaceId) external view returns (bool); 25 | } 26 | -------------------------------------------------------------------------------- /frontend-web3-daap/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "frontend-web3-daap", 3 | "version": "0.1.0", 4 | "private": true, 5 | "dependencies": { 6 | "@testing-library/jest-dom": "^5.14.1", 7 | "@testing-library/react": "^13.0.0", 8 | "@testing-library/user-event": "^13.2.1", 9 | "axios": "^1.7.9", 10 | "ethers": "^6.13.5", 11 | "react": "^19.0.0", 12 | "react-dom": "^19.0.0", 13 | "react-scripts": "5.0.1", 14 | "web-vitals": "^2.1.0" 15 | }, 16 | "scripts": { 17 | "start": "react-scripts start", 18 | "build": "react-scripts build", 19 | "test": "react-scripts test", 20 | "eject": "react-scripts eject" 21 | }, 22 | "eslintConfig": { 23 | "extends": [ 24 | "react-app", 25 | "react-app/jest" 26 | ] 27 | }, 28 | "browserslist": { 29 | "production": [ 30 | ">0.2%", 31 | "not dead", 32 | "not op_mini all" 33 | ], 34 | "development": [ 35 | "last 1 chrome version", 36 | "last 1 firefox version", 37 | "last 1 safari version" 38 | ] 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/EnumerableMap.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "EnumerableMap", 4 | "sourceName": "contracts/utils/structs/EnumerableMap.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "bytes32", 10 | "name": "key", 11 | "type": "bytes32" 12 | } 13 | ], 14 | "name": "EnumerableMapNonexistentKey", 15 | "type": "error" 16 | } 17 | ], 18 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220d94719610d117cb21a552f9e058662286280b1eb20d7fa9aa7263c88029ea54a64736f6c63430008180033", 19 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220d94719610d117cb21a552f9e058662286280b1eb20d7fa9aa7263c88029ea54a64736f6c63430008180033", 20 | "linkReferences": {}, 21 | "deployedLinkReferences": {} 22 | } 23 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721Burnable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC721} from "../ERC721.sol"; 7 | import {Context} from "../../../utils/Context.sol"; 8 | 9 | /** 10 | * @title ERC-721 Burnable Token 11 | * @dev ERC-721 Token that can be burned (destroyed). 12 | */ 13 | abstract contract ERC721Burnable is Context, ERC721 { 14 | /** 15 | * @dev Burns `tokenId`. See {ERC721-_burn}. 16 | * 17 | * Requirements: 18 | * 19 | * - The caller must own `tokenId` or be an approved operator. 20 | */ 21 | function burn(uint256 tokenId) public virtual { 22 | // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists 23 | // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here. 24 | _update(address(0), tokenId, _msgSender()); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashBorrower.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Interface of the ERC-3156 FlashBorrower, as defined in 8 | * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156]. 9 | */ 10 | interface IERC3156FlashBorrower { 11 | /** 12 | * @dev Receive a flash loan. 13 | * @param initiator The initiator of the loan. 14 | * @param token The loan currency. 15 | * @param amount The amount of tokens lent. 16 | * @param fee The additional amount of tokens to repay. 17 | * @param data Arbitrary data structure, intended to contain user-defined parameters. 18 | * @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan" 19 | */ 20 | function onFlashLoan( 21 | address initiator, 22 | address token, 23 | uint256 amount, 24 | uint256 fee, 25 | bytes calldata data 26 | ) external returns (bytes32); 27 | } 28 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IAuthority.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IAuthority", 4 | "sourceName": "contracts/access/manager/IAuthority.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "caller", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "address", 15 | "name": "target", 16 | "type": "address" 17 | }, 18 | { 19 | "internalType": "bytes4", 20 | "name": "selector", 21 | "type": "bytes4" 22 | } 23 | ], 24 | "name": "canCall", 25 | "outputs": [ 26 | { 27 | "internalType": "bool", 28 | "name": "allowed", 29 | "type": "bool" 30 | } 31 | ], 32 | "stateMutability": "view", 33 | "type": "function" 34 | } 35 | ], 36 | "bytecode": "0x", 37 | "deployedBytecode": "0x", 38 | "linkReferences": {}, 39 | "deployedLinkReferences": {} 40 | } 41 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/introspection/ERC165.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC165} from "./IERC165.sol"; 7 | 8 | /** 9 | * @dev Implementation of the {IERC165} interface. 10 | * 11 | * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check 12 | * for the additional interface id that will be supported. For example: 13 | * 14 | * ```solidity 15 | * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { 16 | * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); 17 | * } 18 | * ``` 19 | */ 20 | abstract contract ERC165 is IERC165 { 21 | /** 22 | * @dev See {IERC165-supportsInterface}. 23 | */ 24 | function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { 25 | return interfaceId == type(IERC165).interfaceId; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/Errors.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Collection of common custom errors used in multiple contracts 8 | * 9 | * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library. 10 | * It is recommended to avoid relying on the error API for critical functionality. 11 | * 12 | * _Available since v5.1._ 13 | */ 14 | library Errors { 15 | /** 16 | * @dev The ETH balance of the account is not enough to perform the operation. 17 | */ 18 | error InsufficientBalance(uint256 balance, uint256 needed); 19 | 20 | /** 21 | * @dev A call to an address target failed. The target may have reverted. 22 | */ 23 | error FailedCall(); 24 | 25 | /** 26 | * @dev The deployment failed. 27 | */ 28 | error FailedDeployment(); 29 | 30 | /** 31 | * @dev A necessary precompile is missing. 32 | */ 33 | error MissingPrecompile(address); 34 | } 35 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC1363Spender.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC1363Spender", 4 | "sourceName": "contracts/interfaces/IERC1363Spender.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "owner", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "uint256", 15 | "name": "value", 16 | "type": "uint256" 17 | }, 18 | { 19 | "internalType": "bytes", 20 | "name": "data", 21 | "type": "bytes" 22 | } 23 | ], 24 | "name": "onApprovalReceived", 25 | "outputs": [ 26 | { 27 | "internalType": "bytes4", 28 | "name": "", 29 | "type": "bytes4" 30 | } 31 | ], 32 | "stateMutability": "nonpayable", 33 | "type": "function" 34 | } 35 | ], 36 | "bytecode": "0x", 37 | "deployedBytecode": "0x", 38 | "linkReferences": {}, 39 | "deployedLinkReferences": {} 40 | } 41 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/Context.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Provides information about the current execution context, including the 8 | * sender of the transaction and its data. While these are generally available 9 | * via msg.sender and msg.data, they should not be accessed in such a direct 10 | * manner, since when dealing with meta-transactions the account sending and 11 | * paying for execution may not be the actual sender (as far as an application 12 | * is concerned). 13 | * 14 | * This contract is only required for intermediate, library-like contracts. 15 | */ 16 | abstract contract Context { 17 | function _msgSender() internal view virtual returns (address) { 18 | return msg.sender; 19 | } 20 | 21 | function _msgData() internal view virtual returns (bytes calldata) { 22 | return msg.data; 23 | } 24 | 25 | function _contextSuffixLength() internal view virtual returns (uint256) { 26 | return 0; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC2771Context.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC2771Context", 4 | "sourceName": "contracts/metatx/ERC2771Context.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "forwarder", 11 | "type": "address" 12 | } 13 | ], 14 | "name": "isTrustedForwarder", 15 | "outputs": [ 16 | { 17 | "internalType": "bool", 18 | "name": "", 19 | "type": "bool" 20 | } 21 | ], 22 | "stateMutability": "view", 23 | "type": "function" 24 | }, 25 | { 26 | "inputs": [], 27 | "name": "trustedForwarder", 28 | "outputs": [ 29 | { 30 | "internalType": "address", 31 | "name": "", 32 | "type": "address" 33 | } 34 | ], 35 | "stateMutability": "view", 36 | "type": "function" 37 | } 38 | ], 39 | "bytecode": "0x", 40 | "deployedBytecode": "0x", 41 | "linkReferences": {}, 42 | "deployedLinkReferences": {} 43 | } 44 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ShortStrings.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ShortStrings", 4 | "sourceName": "contracts/utils/ShortStrings.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "InvalidShortString", 9 | "type": "error" 10 | }, 11 | { 12 | "inputs": [ 13 | { 14 | "internalType": "string", 15 | "name": "str", 16 | "type": "string" 17 | } 18 | ], 19 | "name": "StringTooLong", 20 | "type": "error" 21 | } 22 | ], 23 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220b6b527c873e86e4d70b0a27493ad7b42afe222f991207a6ceaf2aeafa71285dc64736f6c63430008180033", 24 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220b6b527c873e86e4d70b0a27493ad7b42afe222f991207a6ceaf2aeafa71285dc64736f6c63430008180033", 25 | "linkReferences": {}, 26 | "deployedLinkReferences": {} 27 | } 28 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Multicall.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Multicall", 4 | "sourceName": "contracts/utils/Multicall.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "target", 11 | "type": "address" 12 | } 13 | ], 14 | "name": "AddressEmptyCode", 15 | "type": "error" 16 | }, 17 | { 18 | "inputs": [], 19 | "name": "FailedCall", 20 | "type": "error" 21 | }, 22 | { 23 | "inputs": [ 24 | { 25 | "internalType": "bytes[]", 26 | "name": "data", 27 | "type": "bytes[]" 28 | } 29 | ], 30 | "name": "multicall", 31 | "outputs": [ 32 | { 33 | "internalType": "bytes[]", 34 | "name": "results", 35 | "type": "bytes[]" 36 | } 37 | ], 38 | "stateMutability": "nonpayable", 39 | "type": "function" 40 | } 41 | ], 42 | "bytecode": "0x", 43 | "deployedBytecode": "0x", 44 | "linkReferences": {}, 45 | "deployedLinkReferences": {} 46 | } 47 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @title ERC-721 token receiver interface 8 | * @dev Interface for any contract that wants to support safeTransfers 9 | * from ERC-721 asset contracts. 10 | */ 11 | interface IERC721Receiver { 12 | /** 13 | * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} 14 | * by `operator` from `from`, this function is called. 15 | * 16 | * It must return its Solidity selector to confirm the token transfer. 17 | * If any other value is returned or the interface is not implemented by the recipient, the transfer will be 18 | * reverted. 19 | * 20 | * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. 21 | */ 22 | function onERC721Received( 23 | address operator, 24 | address from, 25 | uint256 tokenId, 26 | bytes calldata data 27 | ) external returns (bytes4); 28 | } 29 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC2309.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC2309", 4 | "sourceName": "contracts/interfaces/IERC2309.sol", 5 | "abi": [ 6 | { 7 | "anonymous": false, 8 | "inputs": [ 9 | { 10 | "indexed": true, 11 | "internalType": "uint256", 12 | "name": "fromTokenId", 13 | "type": "uint256" 14 | }, 15 | { 16 | "indexed": false, 17 | "internalType": "uint256", 18 | "name": "toTokenId", 19 | "type": "uint256" 20 | }, 21 | { 22 | "indexed": true, 23 | "internalType": "address", 24 | "name": "fromAddress", 25 | "type": "address" 26 | }, 27 | { 28 | "indexed": true, 29 | "internalType": "address", 30 | "name": "toAddress", 31 | "type": "address" 32 | } 33 | ], 34 | "name": "ConsecutiveTransfer", 35 | "type": "event" 36 | } 37 | ], 38 | "bytecode": "0x", 39 | "deployedBytecode": "0x", 40 | "linkReferences": {}, 41 | "deployedLinkReferences": {} 42 | } 43 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/ERC1155Burnable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC1155} from "../ERC1155.sol"; 7 | 8 | /** 9 | * @dev Extension of {ERC1155} that allows token holders to destroy both their 10 | * own tokens and those that they have been approved to use. 11 | */ 12 | abstract contract ERC1155Burnable is ERC1155 { 13 | function burn(address account, uint256 id, uint256 value) public virtual { 14 | if (account != _msgSender() && !isApprovedForAll(account, _msgSender())) { 15 | revert ERC1155MissingApprovalForAll(_msgSender(), account); 16 | } 17 | 18 | _burn(account, id, value); 19 | } 20 | 21 | function burnBatch(address account, uint256[] memory ids, uint256[] memory values) public virtual { 22 | if (account != _msgSender() && !isApprovedForAll(account, _msgSender())) { 23 | revert ERC1155MissingApprovalForAll(_msgSender(), account); 24 | } 25 | 26 | _burnBatch(account, ids, values); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Nonces.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Nonces", 4 | "sourceName": "contracts/utils/Nonces.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "account", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "uint256", 15 | "name": "currentNonce", 16 | "type": "uint256" 17 | } 18 | ], 19 | "name": "InvalidAccountNonce", 20 | "type": "error" 21 | }, 22 | { 23 | "inputs": [ 24 | { 25 | "internalType": "address", 26 | "name": "owner", 27 | "type": "address" 28 | } 29 | ], 30 | "name": "nonces", 31 | "outputs": [ 32 | { 33 | "internalType": "uint256", 34 | "name": "", 35 | "type": "uint256" 36 | } 37 | ], 38 | "stateMutability": "view", 39 | "type": "function" 40 | } 41 | ], 42 | "bytecode": "0x", 43 | "deployedBytecode": "0x", 44 | "linkReferences": {}, 45 | "deployedLinkReferences": {} 46 | } 47 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC721Holder.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC721Holder", 4 | "sourceName": "contracts/token/ERC721/utils/ERC721Holder.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "address", 15 | "name": "", 16 | "type": "address" 17 | }, 18 | { 19 | "internalType": "uint256", 20 | "name": "", 21 | "type": "uint256" 22 | }, 23 | { 24 | "internalType": "bytes", 25 | "name": "", 26 | "type": "bytes" 27 | } 28 | ], 29 | "name": "onERC721Received", 30 | "outputs": [ 31 | { 32 | "internalType": "bytes4", 33 | "name": "", 34 | "type": "bytes4" 35 | } 36 | ], 37 | "stateMutability": "nonpayable", 38 | "type": "function" 39 | } 40 | ], 41 | "bytecode": "0x", 42 | "deployedBytecode": "0x", 43 | "linkReferences": {}, 44 | "deployedLinkReferences": {} 45 | } 46 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/cryptography/Hashes.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/Hashes.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Library of standard hash functions. 8 | * 9 | * _Available since v5.1._ 10 | */ 11 | library Hashes { 12 | /** 13 | * @dev Commutative Keccak256 hash of a sorted pair of bytes32. Frequently used when working with merkle proofs. 14 | * 15 | * NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppelin/merkle-tree[JavaScript library]. 16 | */ 17 | function commutativeKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32) { 18 | return a < b ? _efficientKeccak256(a, b) : _efficientKeccak256(b, a); 19 | } 20 | 21 | /** 22 | * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory. 23 | */ 24 | function _efficientKeccak256(bytes32 a, bytes32 b) private pure returns (bytes32 value) { 25 | assembly ("memory-safe") { 26 | mstore(0x00, a) 27 | mstore(0x20, b) 28 | value := keccak256(0x00, 0x40) 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC721} from "../IERC721.sol"; 7 | 8 | /** 9 | * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension 10 | * @dev See https://eips.ethereum.org/EIPS/eip-721 11 | */ 12 | interface IERC721Enumerable is IERC721 { 13 | /** 14 | * @dev Returns the total amount of tokens stored by the contract. 15 | */ 16 | function totalSupply() external view returns (uint256); 17 | 18 | /** 19 | * @dev Returns a token ID owned by `owner` at a given `index` of its token list. 20 | * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. 21 | */ 22 | function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); 23 | 24 | /** 25 | * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. 26 | * Use along with {totalSupply} to enumerate all tokens. 27 | */ 28 | function tokenByIndex(uint256 index) external view returns (uint256); 29 | } 30 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC1363Receiver.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC1363Receiver", 4 | "sourceName": "contracts/interfaces/IERC1363Receiver.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "operator", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "address", 15 | "name": "from", 16 | "type": "address" 17 | }, 18 | { 19 | "internalType": "uint256", 20 | "name": "value", 21 | "type": "uint256" 22 | }, 23 | { 24 | "internalType": "bytes", 25 | "name": "data", 26 | "type": "bytes" 27 | } 28 | ], 29 | "name": "onTransferReceived", 30 | "outputs": [ 31 | { 32 | "internalType": "bytes4", 33 | "name": "", 34 | "type": "bytes4" 35 | } 36 | ], 37 | "stateMutability": "nonpayable", 38 | "type": "function" 39 | } 40 | ], 41 | "bytecode": "0x", 42 | "deployedBytecode": "0x", 43 | "linkReferences": {}, 44 | "deployedLinkReferences": {} 45 | } 46 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC721Receiver.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC721Receiver", 4 | "sourceName": "contracts/token/ERC721/IERC721Receiver.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "operator", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "address", 15 | "name": "from", 16 | "type": "address" 17 | }, 18 | { 19 | "internalType": "uint256", 20 | "name": "tokenId", 21 | "type": "uint256" 22 | }, 23 | { 24 | "internalType": "bytes", 25 | "name": "data", 26 | "type": "bytes" 27 | } 28 | ], 29 | "name": "onERC721Received", 30 | "outputs": [ 31 | { 32 | "internalType": "bytes4", 33 | "name": "", 34 | "type": "bytes4" 35 | } 36 | ], 37 | "stateMutability": "nonpayable", 38 | "type": "function" 39 | } 40 | ], 41 | "bytecode": "0x", 42 | "deployedBytecode": "0x", 43 | "linkReferences": {}, 44 | "deployedLinkReferences": {} 45 | } 46 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC2981.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC2981.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC165} from "../utils/introspection/IERC165.sol"; 7 | 8 | /** 9 | * @dev Interface for the NFT Royalty Standard. 10 | * 11 | * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal 12 | * support for royalty payments across all NFT marketplaces and ecosystem participants. 13 | */ 14 | interface IERC2981 is IERC165 { 15 | /** 16 | * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of 17 | * exchange. The royalty amount is denominated and should be paid in that same unit of exchange. 18 | * 19 | * NOTE: ERC-2981 allows setting the royalty to 100% of the price. In that case all the price would be sent to the 20 | * royalty receiver and 0 tokens to the seller. Contracts dealing with royalty should consider empty transfers. 21 | */ 22 | function royaltyInfo( 23 | uint256 tokenId, 24 | uint256 salePrice 25 | ) external view returns (address receiver, uint256 royaltyAmount); 26 | } 27 | -------------------------------------------------------------------------------- /backend-smartcontract/README.md: -------------------------------------------------------------------------------- 1 | ## Foundry 2 | 3 | **Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.** 4 | 5 | Foundry consists of: 6 | 7 | - **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools). 8 | - **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data. 9 | - **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network. 10 | - **Chisel**: Fast, utilitarian, and verbose solidity REPL. 11 | 12 | ## Documentation 13 | 14 | https://book.getfoundry.sh/ 15 | 16 | ## Usage 17 | 18 | ### Build 19 | 20 | ```shell 21 | $ forge build 22 | ``` 23 | 24 | ### Test 25 | 26 | ```shell 27 | $ forge test 28 | ``` 29 | 30 | ### Format 31 | 32 | ```shell 33 | $ forge fmt 34 | ``` 35 | 36 | ### Gas Snapshots 37 | 38 | ```shell 39 | $ forge snapshot 40 | ``` 41 | 42 | ### Anvil 43 | 44 | ```shell 45 | $ anvil 46 | ``` 47 | 48 | ### Deploy 49 | 50 | ```shell 51 | $ forge script script/Counter.s.sol:CounterScript --rpc-url --private-key 52 | ``` 53 | 54 | ### Cast 55 | 56 | ```shell 57 | $ cast 58 | ``` 59 | 60 | ### Help 61 | 62 | ```shell 63 | $ forge --help 64 | $ anvil --help 65 | $ cast --help 66 | ``` 67 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC1363Spender.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363Spender.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @title IERC1363Spender 8 | * @dev Interface for any contract that wants to support `approveAndCall` 9 | * from ERC-1363 token contracts. 10 | */ 11 | interface IERC1363Spender { 12 | /** 13 | * @dev Whenever an ERC-1363 token `owner` approves this contract via `approveAndCall` 14 | * to spend their tokens, this function is called. 15 | * 16 | * NOTE: To accept the approval, this must return 17 | * `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))` 18 | * (i.e. 0x7b04a2d0, or its own function selector). 19 | * 20 | * @param owner The address which called `approveAndCall` function and previously owned the tokens. 21 | * @param value The amount of tokens to be spent. 22 | * @param data Additional data with no specified format. 23 | * @return `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))` if approval is allowed unless throwing. 24 | */ 25 | function onApprovalReceived(address owner, uint256 value, bytes calldata data) external returns (bytes4); 26 | } 27 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/access/manager/IAccessManaged.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManaged.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | interface IAccessManaged { 7 | /** 8 | * @dev Authority that manages this contract was updated. 9 | */ 10 | event AuthorityUpdated(address authority); 11 | 12 | error AccessManagedUnauthorized(address caller); 13 | error AccessManagedRequiredDelay(address caller, uint32 delay); 14 | error AccessManagedInvalidAuthority(address authority); 15 | 16 | /** 17 | * @dev Returns the current authority. 18 | */ 19 | function authority() external view returns (address); 20 | 21 | /** 22 | * @dev Transfers control to a new authority. The caller must be the current authority. 23 | */ 24 | function setAuthority(address) external; 25 | 26 | /** 27 | * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is 28 | * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs 29 | * attacker controlled calls. 30 | */ 31 | function isConsumingScheduledOp() external view returns (bytes4); 32 | } 33 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC1363Utils.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC1363Utils", 4 | "sourceName": "contracts/token/ERC20/utils/ERC1363Utils.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "receiver", 11 | "type": "address" 12 | } 13 | ], 14 | "name": "ERC1363InvalidReceiver", 15 | "type": "error" 16 | }, 17 | { 18 | "inputs": [ 19 | { 20 | "internalType": "address", 21 | "name": "spender", 22 | "type": "address" 23 | } 24 | ], 25 | "name": "ERC1363InvalidSpender", 26 | "type": "error" 27 | } 28 | ], 29 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212208b0a0513d45a44ff54f50da2e338f9f98da0d28fd8b3a9060175b9e8625c6c3164736f6c63430008180033", 30 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212208b0a0513d45a44ff54f50da2e338f9f98da0d28fd8b3a9060175b9e8625c6c3164736f6c63430008180033", 31 | "linkReferences": {}, 32 | "deployedLinkReferences": {} 33 | } 34 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC777Sender.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC777Sender", 4 | "sourceName": "contracts/interfaces/IERC777Sender.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "operator", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "address", 15 | "name": "from", 16 | "type": "address" 17 | }, 18 | { 19 | "internalType": "address", 20 | "name": "to", 21 | "type": "address" 22 | }, 23 | { 24 | "internalType": "uint256", 25 | "name": "amount", 26 | "type": "uint256" 27 | }, 28 | { 29 | "internalType": "bytes", 30 | "name": "userData", 31 | "type": "bytes" 32 | }, 33 | { 34 | "internalType": "bytes", 35 | "name": "operatorData", 36 | "type": "bytes" 37 | } 38 | ], 39 | "name": "tokensToSend", 40 | "outputs": [], 41 | "stateMutability": "nonpayable", 42 | "type": "function" 43 | } 44 | ], 45 | "bytecode": "0x", 46 | "deployedBytecode": "0x", 47 | "linkReferences": {}, 48 | "deployedLinkReferences": {} 49 | } 50 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC777Recipient.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC777Recipient", 4 | "sourceName": "contracts/interfaces/IERC777Recipient.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "operator", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "address", 15 | "name": "from", 16 | "type": "address" 17 | }, 18 | { 19 | "internalType": "address", 20 | "name": "to", 21 | "type": "address" 22 | }, 23 | { 24 | "internalType": "uint256", 25 | "name": "amount", 26 | "type": "uint256" 27 | }, 28 | { 29 | "internalType": "bytes", 30 | "name": "userData", 31 | "type": "bytes" 32 | }, 33 | { 34 | "internalType": "bytes", 35 | "name": "operatorData", 36 | "type": "bytes" 37 | } 38 | ], 39 | "name": "tokensReceived", 40 | "outputs": [], 41 | "stateMutability": "nonpayable", 42 | "type": "function" 43 | } 44 | ], 45 | "bytecode": "0x", 46 | "deployedBytecode": "0x", 47 | "linkReferences": {}, 48 | "deployedLinkReferences": {} 49 | } 50 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC3156FlashBorrower.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC3156FlashBorrower", 4 | "sourceName": "contracts/interfaces/IERC3156FlashBorrower.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "initiator", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "address", 15 | "name": "token", 16 | "type": "address" 17 | }, 18 | { 19 | "internalType": "uint256", 20 | "name": "amount", 21 | "type": "uint256" 22 | }, 23 | { 24 | "internalType": "uint256", 25 | "name": "fee", 26 | "type": "uint256" 27 | }, 28 | { 29 | "internalType": "bytes", 30 | "name": "data", 31 | "type": "bytes" 32 | } 33 | ], 34 | "name": "onFlashLoan", 35 | "outputs": [ 36 | { 37 | "internalType": "bytes32", 38 | "name": "", 39 | "type": "bytes32" 40 | } 41 | ], 42 | "stateMutability": "nonpayable", 43 | "type": "function" 44 | } 45 | ], 46 | "bytecode": "0x", 47 | "deployedBytecode": "0x", 48 | "linkReferences": {}, 49 | "deployedLinkReferences": {} 50 | } 51 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Strings.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Strings", 4 | "sourceName": "contracts/utils/Strings.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "uint256", 10 | "name": "value", 11 | "type": "uint256" 12 | }, 13 | { 14 | "internalType": "uint256", 15 | "name": "length", 16 | "type": "uint256" 17 | } 18 | ], 19 | "name": "StringsInsufficientHexLength", 20 | "type": "error" 21 | }, 22 | { 23 | "inputs": [], 24 | "name": "StringsInvalidAddressFormat", 25 | "type": "error" 26 | }, 27 | { 28 | "inputs": [], 29 | "name": "StringsInvalidChar", 30 | "type": "error" 31 | } 32 | ], 33 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122042c3595ea00d1d1f7c78125284ebd5387bebfe8b7b51dc1069a32081f657cb7764736f6c63430008180033", 34 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea264697066735822122042c3595ea00d1d1f7c78125284ebd5387bebfe8b7b51dc1069a32081f657cb7764736f6c63430008180033", 35 | "linkReferences": {}, 36 | "deployedLinkReferences": {} 37 | } 38 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC20} from "../ERC20.sol"; 7 | import {Context} from "../../../utils/Context.sol"; 8 | 9 | /** 10 | * @dev Extension of {ERC20} that allows token holders to destroy both their own 11 | * tokens and those that they have an allowance for, in a way that can be 12 | * recognized off-chain (via event analysis). 13 | */ 14 | abstract contract ERC20Burnable is Context, ERC20 { 15 | /** 16 | * @dev Destroys a `value` amount of tokens from the caller. 17 | * 18 | * See {ERC20-_burn}. 19 | */ 20 | function burn(uint256 value) public virtual { 21 | _burn(_msgSender(), value); 22 | } 23 | 24 | /** 25 | * @dev Destroys a `value` amount of tokens from `account`, deducting from 26 | * the caller's allowance. 27 | * 28 | * See {ERC20-_burn} and {ERC20-allowance}. 29 | * 30 | * Requirements: 31 | * 32 | * - the caller must have allowance for ``accounts``'s tokens of at least 33 | * `value`. 34 | */ 35 | function burnFrom(address account, uint256 value) public virtual { 36 | _spendAllowance(account, _msgSender(), value); 37 | _burn(account, value); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721Royalty.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC721} from "../ERC721.sol"; 7 | import {ERC2981} from "../../common/ERC2981.sol"; 8 | 9 | /** 10 | * @dev Extension of ERC-721 with the ERC-2981 NFT Royalty Standard, a standardized way to retrieve royalty payment 11 | * information. 12 | * 13 | * Royalty information can be specified globally for all token ids via {ERC2981-_setDefaultRoyalty}, and/or individually 14 | * for specific token ids via {ERC2981-_setTokenRoyalty}. The latter takes precedence over the first. 15 | * 16 | * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See 17 | * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the ERC. Marketplaces are expected to 18 | * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. 19 | */ 20 | abstract contract ERC721Royalty is ERC2981, ERC721 { 21 | /** 22 | * @dev See {IERC165-supportsInterface}. 23 | */ 24 | function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) { 25 | return super.supportsInterface(interfaceId); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/access/manager/AuthorityUtils.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AuthorityUtils.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IAuthority} from "./IAuthority.sol"; 7 | 8 | library AuthorityUtils { 9 | /** 10 | * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility 11 | * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data. 12 | * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting. 13 | */ 14 | function canCallWithDelay( 15 | address authority, 16 | address caller, 17 | address target, 18 | bytes4 selector 19 | ) internal view returns (bool immediate, uint32 delay) { 20 | (bool success, bytes memory data) = authority.staticcall( 21 | abi.encodeCall(IAuthority.canCall, (caller, target, selector)) 22 | ); 23 | if (success) { 24 | if (data.length >= 0x40) { 25 | (immediate, delay) = abi.decode(data, (bool, uint32)); 26 | } else if (data.length >= 0x20) { 27 | immediate = abi.decode(data, (bool)); 28 | } 29 | } 30 | return (immediate, delay); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ECDSA.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ECDSA", 4 | "sourceName": "contracts/utils/cryptography/ECDSA.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "ECDSAInvalidSignature", 9 | "type": "error" 10 | }, 11 | { 12 | "inputs": [ 13 | { 14 | "internalType": "uint256", 15 | "name": "length", 16 | "type": "uint256" 17 | } 18 | ], 19 | "name": "ECDSAInvalidSignatureLength", 20 | "type": "error" 21 | }, 22 | { 23 | "inputs": [ 24 | { 25 | "internalType": "bytes32", 26 | "name": "s", 27 | "type": "bytes32" 28 | } 29 | ], 30 | "name": "ECDSAInvalidSignatureS", 31 | "type": "error" 32 | } 33 | ], 34 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220e89cd2162008caf70e5f75f1508efb42247af19c9e631fce751e038839e005ea64736f6c63430008180033", 35 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220e89cd2162008caf70e5f75f1508efb42247af19c9e631fce751e038839e005ea64736f6c63430008180033", 36 | "linkReferences": {}, 37 | "deployedLinkReferences": {} 38 | } 39 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC7579Execution.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC7579Execution", 4 | "sourceName": "contracts/interfaces/draft-IERC7579.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "bytes32", 10 | "name": "mode", 11 | "type": "bytes32" 12 | }, 13 | { 14 | "internalType": "bytes", 15 | "name": "executionCalldata", 16 | "type": "bytes" 17 | } 18 | ], 19 | "name": "execute", 20 | "outputs": [], 21 | "stateMutability": "payable", 22 | "type": "function" 23 | }, 24 | { 25 | "inputs": [ 26 | { 27 | "internalType": "bytes32", 28 | "name": "mode", 29 | "type": "bytes32" 30 | }, 31 | { 32 | "internalType": "bytes", 33 | "name": "executionCalldata", 34 | "type": "bytes" 35 | } 36 | ], 37 | "name": "executeFromExecutor", 38 | "outputs": [ 39 | { 40 | "internalType": "bytes[]", 41 | "name": "returnData", 42 | "type": "bytes[]" 43 | } 44 | ], 45 | "stateMutability": "payable", 46 | "type": "function" 47 | } 48 | ], 49 | "bytecode": "0x", 50 | "deployedBytecode": "0x", 51 | "linkReferences": {}, 52 | "deployedLinkReferences": {} 53 | } 54 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC7579Module.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC7579Module", 4 | "sourceName": "contracts/interfaces/draft-IERC7579.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "uint256", 10 | "name": "moduleTypeId", 11 | "type": "uint256" 12 | } 13 | ], 14 | "name": "isModuleType", 15 | "outputs": [ 16 | { 17 | "internalType": "bool", 18 | "name": "", 19 | "type": "bool" 20 | } 21 | ], 22 | "stateMutability": "view", 23 | "type": "function" 24 | }, 25 | { 26 | "inputs": [ 27 | { 28 | "internalType": "bytes", 29 | "name": "data", 30 | "type": "bytes" 31 | } 32 | ], 33 | "name": "onInstall", 34 | "outputs": [], 35 | "stateMutability": "nonpayable", 36 | "type": "function" 37 | }, 38 | { 39 | "inputs": [ 40 | { 41 | "internalType": "bytes", 42 | "name": "data", 43 | "type": "bytes" 44 | } 45 | ], 46 | "name": "onUninstall", 47 | "outputs": [], 48 | "stateMutability": "nonpayable", 49 | "type": "function" 50 | } 51 | ], 52 | "bytecode": "0x", 53 | "deployedBytecode": "0x", 54 | "linkReferences": {}, 55 | "deployedLinkReferences": {} 56 | } 57 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC20/extensions/ERC20Pausable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/ERC20Pausable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC20} from "../ERC20.sol"; 7 | import {Pausable} from "../../../utils/Pausable.sol"; 8 | 9 | /** 10 | * @dev ERC-20 token with pausable token transfers, minting and burning. 11 | * 12 | * Useful for scenarios such as preventing trades until the end of an evaluation 13 | * period, or having an emergency switch for freezing all token transfers in the 14 | * event of a large bug. 15 | * 16 | * IMPORTANT: This contract does not include public pause and unpause functions. In 17 | * addition to inheriting this contract, you must define both functions, invoking the 18 | * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate 19 | * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will 20 | * make the contract pause mechanism of the contract unreachable, and thus unusable. 21 | */ 22 | abstract contract ERC20Pausable is ERC20, Pausable { 23 | /** 24 | * @dev See {ERC20-_update}. 25 | * 26 | * Requirements: 27 | * 28 | * - the contract must not be paused. 29 | */ 30 | function _update(address from, address to, uint256 value) internal virtual override whenNotPaused { 31 | super._update(from, to, value); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC777Recipient.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC777Recipient.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Interface of the ERC-777 Tokens Recipient standard as defined in the ERC. 8 | * 9 | * Accounts can be notified of {IERC777} tokens being sent to them by having a 10 | * contract implement this interface (contract holders can be their own 11 | * implementer) and registering it on the 12 | * https://eips.ethereum.org/EIPS/eip-1820[ERC-1820 global registry]. 13 | * 14 | * See {IERC1820Registry} and {IERC1820Implementer}. 15 | */ 16 | interface IERC777Recipient { 17 | /** 18 | * @dev Called by an {IERC777} token contract whenever tokens are being 19 | * moved or created into a registered account (`to`). The type of operation 20 | * is conveyed by `from` being the zero address or not. 21 | * 22 | * This call occurs _after_ the token contract's state is updated, so 23 | * {IERC777-balanceOf}, etc., can be used to query the post-operation state. 24 | * 25 | * This function may revert to prevent the operation from being executed. 26 | */ 27 | function tokensReceived( 28 | address operator, 29 | address from, 30 | address to, 31 | uint256 amount, 32 | bytes calldata userData, 33 | bytes calldata operatorData 34 | ) external; 35 | } 36 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/access/extensions/IAccessControlEnumerable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (access/extensions/IAccessControlEnumerable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IAccessControl} from "../IAccessControl.sol"; 7 | 8 | /** 9 | * @dev External interface of AccessControlEnumerable declared to support ERC-165 detection. 10 | */ 11 | interface IAccessControlEnumerable is IAccessControl { 12 | /** 13 | * @dev Returns one of the accounts that have `role`. `index` must be a 14 | * value between 0 and {getRoleMemberCount}, non-inclusive. 15 | * 16 | * Role bearers are not sorted in any particular way, and their ordering may 17 | * change at any point. 18 | * 19 | * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure 20 | * you perform all queries on the same block. See the following 21 | * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] 22 | * for more information. 23 | */ 24 | function getRoleMember(bytes32 role, uint256 index) external view returns (address); 25 | 26 | /** 27 | * @dev Returns the number of accounts that have `role`. Can be used 28 | * together with {getRoleMember} to enumerate all bearers of a role. 29 | */ 30 | function getRoleMemberCount(bytes32 role) external view returns (uint256); 31 | } 32 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC1967.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC1967", 4 | "sourceName": "contracts/interfaces/IERC1967.sol", 5 | "abi": [ 6 | { 7 | "anonymous": false, 8 | "inputs": [ 9 | { 10 | "indexed": false, 11 | "internalType": "address", 12 | "name": "previousAdmin", 13 | "type": "address" 14 | }, 15 | { 16 | "indexed": false, 17 | "internalType": "address", 18 | "name": "newAdmin", 19 | "type": "address" 20 | } 21 | ], 22 | "name": "AdminChanged", 23 | "type": "event" 24 | }, 25 | { 26 | "anonymous": false, 27 | "inputs": [ 28 | { 29 | "indexed": true, 30 | "internalType": "address", 31 | "name": "beacon", 32 | "type": "address" 33 | } 34 | ], 35 | "name": "BeaconUpgraded", 36 | "type": "event" 37 | }, 38 | { 39 | "anonymous": false, 40 | "inputs": [ 41 | { 42 | "indexed": true, 43 | "internalType": "address", 44 | "name": "implementation", 45 | "type": "address" 46 | } 47 | ], 48 | "name": "Upgraded", 49 | "type": "event" 50 | } 51 | ], 52 | "bytecode": "0x", 53 | "deployedBytecode": "0x", 54 | "linkReferences": {}, 55 | "deployedLinkReferences": {} 56 | } 57 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC777Sender.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC777Sender.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Interface of the ERC-777 Tokens Sender standard as defined in the ERC. 8 | * 9 | * {IERC777} Token holders can be notified of operations performed on their 10 | * tokens by having a contract implement this interface (contract holders can be 11 | * their own implementer) and registering it on the 12 | * https://eips.ethereum.org/EIPS/eip-1820[ERC-1820 global registry]. 13 | * 14 | * See {IERC1820Registry} and {IERC1820Implementer}. 15 | */ 16 | interface IERC777Sender { 17 | /** 18 | * @dev Called by an {IERC777} token contract whenever a registered holder's 19 | * (`from`) tokens are about to be moved or destroyed. The type of operation 20 | * is conveyed by `to` being the zero address or not. 21 | * 22 | * This call occurs _before_ the token contract's state is updated, so 23 | * {IERC777-balanceOf}, etc., can be used to query the pre-operation state. 24 | * 25 | * This function may revert to prevent the operation from being executed. 26 | */ 27 | function tokensToSend( 28 | address operator, 29 | address from, 30 | address to, 31 | uint256 amount, 32 | bytes calldata userData, 33 | bytes calldata operatorData 34 | ) external; 35 | } 36 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Pausable.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Pausable", 4 | "sourceName": "contracts/utils/Pausable.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "EnforcedPause", 9 | "type": "error" 10 | }, 11 | { 12 | "inputs": [], 13 | "name": "ExpectedPause", 14 | "type": "error" 15 | }, 16 | { 17 | "anonymous": false, 18 | "inputs": [ 19 | { 20 | "indexed": false, 21 | "internalType": "address", 22 | "name": "account", 23 | "type": "address" 24 | } 25 | ], 26 | "name": "Paused", 27 | "type": "event" 28 | }, 29 | { 30 | "anonymous": false, 31 | "inputs": [ 32 | { 33 | "indexed": false, 34 | "internalType": "address", 35 | "name": "account", 36 | "type": "address" 37 | } 38 | ], 39 | "name": "Unpaused", 40 | "type": "event" 41 | }, 42 | { 43 | "inputs": [], 44 | "name": "paused", 45 | "outputs": [ 46 | { 47 | "internalType": "bool", 48 | "name": "", 49 | "type": "bool" 50 | } 51 | ], 52 | "stateMutability": "view", 53 | "type": "function" 54 | } 55 | ], 56 | "bytecode": "0x", 57 | "deployedBytecode": "0x", 58 | "linkReferences": {}, 59 | "deployedLinkReferences": {} 60 | } 61 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC1363Receiver.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363Receiver.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @title IERC1363Receiver 8 | * @dev Interface for any contract that wants to support `transferAndCall` or `transferFromAndCall` 9 | * from ERC-1363 token contracts. 10 | */ 11 | interface IERC1363Receiver { 12 | /** 13 | * @dev Whenever ERC-1363 tokens are transferred to this contract via `transferAndCall` or `transferFromAndCall` 14 | * by `operator` from `from`, this function is called. 15 | * 16 | * NOTE: To accept the transfer, this must return 17 | * `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))` 18 | * (i.e. 0x88a7ca5c, or its own function selector). 19 | * 20 | * @param operator The address which called `transferAndCall` or `transferFromAndCall` function. 21 | * @param from The address which the tokens are transferred from. 22 | * @param value The amount of tokens transferred. 23 | * @param data Additional data with no specified format. 24 | * @return `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))` if transfer is allowed unless throwing. 25 | */ 26 | function onTransferReceived( 27 | address operator, 28 | address from, 29 | uint256 value, 30 | bytes calldata data 31 | ) external returns (bytes4); 32 | } 33 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721Pausable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC721} from "../ERC721.sol"; 7 | import {Pausable} from "../../../utils/Pausable.sol"; 8 | 9 | /** 10 | * @dev ERC-721 token with pausable token transfers, minting and burning. 11 | * 12 | * Useful for scenarios such as preventing trades until the end of an evaluation 13 | * period, or having an emergency switch for freezing all token transfers in the 14 | * event of a large bug. 15 | * 16 | * IMPORTANT: This contract does not include public pause and unpause functions. In 17 | * addition to inheriting this contract, you must define both functions, invoking the 18 | * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate 19 | * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will 20 | * make the contract pause mechanism of the contract unreachable, and thus unusable. 21 | */ 22 | abstract contract ERC721Pausable is ERC721, Pausable { 23 | /** 24 | * @dev See {ERC721-_update}. 25 | * 26 | * Requirements: 27 | * 28 | * - the contract must not be paused. 29 | */ 30 | function _update( 31 | address to, 32 | uint256 tokenId, 33 | address auth 34 | ) internal virtual override whenNotPaused returns (address) { 35 | return super._update(to, tokenId, auth); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC2981.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC2981", 4 | "sourceName": "contracts/interfaces/IERC2981.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "uint256", 10 | "name": "tokenId", 11 | "type": "uint256" 12 | }, 13 | { 14 | "internalType": "uint256", 15 | "name": "salePrice", 16 | "type": "uint256" 17 | } 18 | ], 19 | "name": "royaltyInfo", 20 | "outputs": [ 21 | { 22 | "internalType": "address", 23 | "name": "receiver", 24 | "type": "address" 25 | }, 26 | { 27 | "internalType": "uint256", 28 | "name": "royaltyAmount", 29 | "type": "uint256" 30 | } 31 | ], 32 | "stateMutability": "view", 33 | "type": "function" 34 | }, 35 | { 36 | "inputs": [ 37 | { 38 | "internalType": "bytes4", 39 | "name": "interfaceId", 40 | "type": "bytes4" 41 | } 42 | ], 43 | "name": "supportsInterface", 44 | "outputs": [ 45 | { 46 | "internalType": "bool", 47 | "name": "", 48 | "type": "bool" 49 | } 50 | ], 51 | "stateMutability": "view", 52 | "type": "function" 53 | } 54 | ], 55 | "bytecode": "0x", 56 | "deployedBytecode": "0x", 57 | "linkReferences": {}, 58 | "deployedLinkReferences": {} 59 | } 60 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Pausable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/extensions/ERC1155Pausable.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC1155} from "../ERC1155.sol"; 7 | import {Pausable} from "../../../utils/Pausable.sol"; 8 | 9 | /** 10 | * @dev ERC-1155 token with pausable token transfers, minting and burning. 11 | * 12 | * Useful for scenarios such as preventing trades until the end of an evaluation 13 | * period, or having an emergency switch for freezing all token transfers in the 14 | * event of a large bug. 15 | * 16 | * IMPORTANT: This contract does not include public pause and unpause functions. In 17 | * addition to inheriting this contract, you must define both functions, invoking the 18 | * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate 19 | * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will 20 | * make the contract pause mechanism of the contract unreachable, and thus unusable. 21 | */ 22 | abstract contract ERC1155Pausable is ERC1155, Pausable { 23 | /** 24 | * @dev See {ERC1155-_update}. 25 | * 26 | * Requirements: 27 | * 28 | * - the contract must not be paused. 29 | */ 30 | function _update( 31 | address from, 32 | address to, 33 | uint256[] memory ids, 34 | uint256[] memory values 35 | ) internal virtual override whenNotPaused { 36 | super._update(from, to, ids, values); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/utils/ERC1155Holder.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC165, ERC165} from "../../../utils/introspection/ERC165.sol"; 7 | import {IERC1155Receiver} from "../IERC1155Receiver.sol"; 8 | 9 | /** 10 | * @dev Simple implementation of `IERC1155Receiver` that will allow a contract to hold ERC-1155 tokens. 11 | * 12 | * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be 13 | * stuck. 14 | */ 15 | abstract contract ERC1155Holder is ERC165, IERC1155Receiver { 16 | /** 17 | * @dev See {IERC165-supportsInterface}. 18 | */ 19 | function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { 20 | return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId); 21 | } 22 | 23 | function onERC1155Received( 24 | address, 25 | address, 26 | uint256, 27 | uint256, 28 | bytes memory 29 | ) public virtual override returns (bytes4) { 30 | return this.onERC1155Received.selector; 31 | } 32 | 33 | function onERC1155BatchReceived( 34 | address, 35 | address, 36 | uint256[] memory, 37 | uint256[] memory, 38 | bytes memory 39 | ) public virtual override returns (bytes4) { 40 | return this.onERC1155BatchReceived.selector; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/SafeERC20.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "SafeERC20", 4 | "sourceName": "contracts/token/ERC20/utils/SafeERC20.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "spender", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "uint256", 15 | "name": "currentAllowance", 16 | "type": "uint256" 17 | }, 18 | { 19 | "internalType": "uint256", 20 | "name": "requestedDecrease", 21 | "type": "uint256" 22 | } 23 | ], 24 | "name": "SafeERC20FailedDecreaseAllowance", 25 | "type": "error" 26 | }, 27 | { 28 | "inputs": [ 29 | { 30 | "internalType": "address", 31 | "name": "token", 32 | "type": "address" 33 | } 34 | ], 35 | "name": "SafeERC20FailedOperation", 36 | "type": "error" 37 | } 38 | ], 39 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220d958548954339e4559b2e73514d5979d1756a10c8375e2176ec21500cadb161464736f6c63430008180033", 40 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220d958548954339e4559b2e73514d5979d1756a10c8375e2176ec21500cadb161464736f6c63430008180033", 41 | "linkReferences": {}, 42 | "deployedLinkReferences": {} 43 | } 44 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Errors.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Errors", 4 | "sourceName": "contracts/utils/Errors.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "FailedCall", 9 | "type": "error" 10 | }, 11 | { 12 | "inputs": [], 13 | "name": "FailedDeployment", 14 | "type": "error" 15 | }, 16 | { 17 | "inputs": [ 18 | { 19 | "internalType": "uint256", 20 | "name": "balance", 21 | "type": "uint256" 22 | }, 23 | { 24 | "internalType": "uint256", 25 | "name": "needed", 26 | "type": "uint256" 27 | } 28 | ], 29 | "name": "InsufficientBalance", 30 | "type": "error" 31 | }, 32 | { 33 | "inputs": [ 34 | { 35 | "internalType": "address", 36 | "name": "", 37 | "type": "address" 38 | } 39 | ], 40 | "name": "MissingPrecompile", 41 | "type": "error" 42 | } 43 | ], 44 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212203ef5b8c947a392a82f859bf3783be651f3832c0a538fd9e4f9b01f3791b0866964736f6c63430008180033", 45 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212203ef5b8c947a392a82f859bf3783be651f3832c0a538fd9e4f9b01f3791b0866964736f6c63430008180033", 46 | "linkReferences": {}, 47 | "deployedLinkReferences": {} 48 | } 49 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC5267.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC5267", 4 | "sourceName": "contracts/interfaces/IERC5267.sol", 5 | "abi": [ 6 | { 7 | "anonymous": false, 8 | "inputs": [], 9 | "name": "EIP712DomainChanged", 10 | "type": "event" 11 | }, 12 | { 13 | "inputs": [], 14 | "name": "eip712Domain", 15 | "outputs": [ 16 | { 17 | "internalType": "bytes1", 18 | "name": "fields", 19 | "type": "bytes1" 20 | }, 21 | { 22 | "internalType": "string", 23 | "name": "name", 24 | "type": "string" 25 | }, 26 | { 27 | "internalType": "string", 28 | "name": "version", 29 | "type": "string" 30 | }, 31 | { 32 | "internalType": "uint256", 33 | "name": "chainId", 34 | "type": "uint256" 35 | }, 36 | { 37 | "internalType": "address", 38 | "name": "verifyingContract", 39 | "type": "address" 40 | }, 41 | { 42 | "internalType": "bytes32", 43 | "name": "salt", 44 | "type": "bytes32" 45 | }, 46 | { 47 | "internalType": "uint256[]", 48 | "name": "extensions", 49 | "type": "uint256[]" 50 | } 51 | ], 52 | "stateMutability": "view", 53 | "type": "function" 54 | } 55 | ], 56 | "bytecode": "0x", 57 | "deployedBytecode": "0x", 58 | "linkReferences": {}, 59 | "deployedLinkReferences": {} 60 | } 61 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC7579AccountConfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC7579AccountConfig", 4 | "sourceName": "contracts/interfaces/draft-IERC7579.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "accountId", 9 | "outputs": [ 10 | { 11 | "internalType": "string", 12 | "name": "accountImplementationId", 13 | "type": "string" 14 | } 15 | ], 16 | "stateMutability": "view", 17 | "type": "function" 18 | }, 19 | { 20 | "inputs": [ 21 | { 22 | "internalType": "bytes32", 23 | "name": "encodedMode", 24 | "type": "bytes32" 25 | } 26 | ], 27 | "name": "supportsExecutionMode", 28 | "outputs": [ 29 | { 30 | "internalType": "bool", 31 | "name": "", 32 | "type": "bool" 33 | } 34 | ], 35 | "stateMutability": "view", 36 | "type": "function" 37 | }, 38 | { 39 | "inputs": [ 40 | { 41 | "internalType": "uint256", 42 | "name": "moduleTypeId", 43 | "type": "uint256" 44 | } 45 | ], 46 | "name": "supportsModule", 47 | "outputs": [ 48 | { 49 | "internalType": "bool", 50 | "name": "", 51 | "type": "bool" 52 | } 53 | ], 54 | "stateMutability": "view", 55 | "type": "function" 56 | } 57 | ], 58 | "bytecode": "0x", 59 | "deployedBytecode": "0x", 60 | "linkReferences": {}, 61 | "deployedLinkReferences": {} 62 | } 63 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashLender.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC3156FlashBorrower} from "./IERC3156FlashBorrower.sol"; 7 | 8 | /** 9 | * @dev Interface of the ERC-3156 FlashLender, as defined in 10 | * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156]. 11 | */ 12 | interface IERC3156FlashLender { 13 | /** 14 | * @dev The amount of currency available to be lended. 15 | * @param token The loan currency. 16 | * @return The amount of `token` that can be borrowed. 17 | */ 18 | function maxFlashLoan(address token) external view returns (uint256); 19 | 20 | /** 21 | * @dev The fee to be charged for a given loan. 22 | * @param token The loan currency. 23 | * @param amount The amount of tokens lent. 24 | * @return The amount of `token` to be charged for the loan, on top of the returned principal. 25 | */ 26 | function flashFee(address token, uint256 amount) external view returns (uint256); 27 | 28 | /** 29 | * @dev Initiate a flash loan. 30 | * @param receiver The receiver of the tokens in the loan, and the receiver of the callback. 31 | * @param token The loan currency. 32 | * @param amount The amount of tokens lent. 33 | * @param data Arbitrary data structure, intended to contain user-defined parameters. 34 | */ 35 | function flashLoan( 36 | IERC3156FlashBorrower receiver, 37 | address token, 38 | uint256 amount, 39 | bytes calldata data 40 | ) external returns (bool); 41 | } 42 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ERC1967Utils.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ERC1967Utils", 4 | "sourceName": "contracts/proxy/ERC1967/ERC1967Utils.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "admin", 11 | "type": "address" 12 | } 13 | ], 14 | "name": "ERC1967InvalidAdmin", 15 | "type": "error" 16 | }, 17 | { 18 | "inputs": [ 19 | { 20 | "internalType": "address", 21 | "name": "beacon", 22 | "type": "address" 23 | } 24 | ], 25 | "name": "ERC1967InvalidBeacon", 26 | "type": "error" 27 | }, 28 | { 29 | "inputs": [ 30 | { 31 | "internalType": "address", 32 | "name": "implementation", 33 | "type": "address" 34 | } 35 | ], 36 | "name": "ERC1967InvalidImplementation", 37 | "type": "error" 38 | }, 39 | { 40 | "inputs": [], 41 | "name": "ERC1967NonPayable", 42 | "type": "error" 43 | } 44 | ], 45 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212209d31872babb0b592441f0cbe12b44343fa2304e0bb58626b05fe6eb651a172c664736f6c63430008180033", 46 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212209d31872babb0b592441f0cbe12b44343fa2304e0bb58626b05fe6eb651a172c664736f6c63430008180033", 47 | "linkReferences": {}, 48 | "deployedLinkReferences": {} 49 | } 50 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/Nonces.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol) 3 | pragma solidity ^0.8.20; 4 | 5 | /** 6 | * @dev Provides tracking nonces for addresses. Nonces will only increment. 7 | */ 8 | abstract contract Nonces { 9 | /** 10 | * @dev The nonce used for an `account` is not the expected current nonce. 11 | */ 12 | error InvalidAccountNonce(address account, uint256 currentNonce); 13 | 14 | mapping(address account => uint256) private _nonces; 15 | 16 | /** 17 | * @dev Returns the next unused nonce for an address. 18 | */ 19 | function nonces(address owner) public view virtual returns (uint256) { 20 | return _nonces[owner]; 21 | } 22 | 23 | /** 24 | * @dev Consumes a nonce. 25 | * 26 | * Returns the current value and increments nonce. 27 | */ 28 | function _useNonce(address owner) internal virtual returns (uint256) { 29 | // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be 30 | // decremented or reset. This guarantees that the nonce never overflows. 31 | unchecked { 32 | // It is important to do x++ and not ++x here. 33 | return _nonces[owner]++; 34 | } 35 | } 36 | 37 | /** 38 | * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`. 39 | */ 40 | function _useCheckedNonce(address owner, uint256 nonce) internal virtual { 41 | uint256 current = _useNonce(owner); 42 | if (nonce != current) { 43 | revert InvalidAccountNonce(owner, current); 44 | } 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Capped.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC20} from "../ERC20.sol"; 7 | 8 | /** 9 | * @dev Extension of {ERC20} that adds a cap to the supply of tokens. 10 | */ 11 | abstract contract ERC20Capped is ERC20 { 12 | uint256 private immutable _cap; 13 | 14 | /** 15 | * @dev Total supply cap has been exceeded. 16 | */ 17 | error ERC20ExceededCap(uint256 increasedSupply, uint256 cap); 18 | 19 | /** 20 | * @dev The supplied cap is not a valid cap. 21 | */ 22 | error ERC20InvalidCap(uint256 cap); 23 | 24 | /** 25 | * @dev Sets the value of the `cap`. This value is immutable, it can only be 26 | * set once during construction. 27 | */ 28 | constructor(uint256 cap_) { 29 | if (cap_ == 0) { 30 | revert ERC20InvalidCap(0); 31 | } 32 | _cap = cap_; 33 | } 34 | 35 | /** 36 | * @dev Returns the cap on the token's total supply. 37 | */ 38 | function cap() public view virtual returns (uint256) { 39 | return _cap; 40 | } 41 | 42 | /** 43 | * @dev See {ERC20-_update}. 44 | */ 45 | function _update(address from, address to, uint256 value) internal virtual override { 46 | super._update(from, to, value); 47 | 48 | if (from == address(0)) { 49 | uint256 maxSupply = cap(); 50 | uint256 supply = totalSupply(); 51 | if (supply > maxSupply) { 52 | revert ERC20ExceededCap(supply, maxSupply); 53 | } 54 | } 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/NoncesKeyed.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "NoncesKeyed", 4 | "sourceName": "contracts/utils/NoncesKeyed.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "account", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "uint256", 15 | "name": "currentNonce", 16 | "type": "uint256" 17 | } 18 | ], 19 | "name": "InvalidAccountNonce", 20 | "type": "error" 21 | }, 22 | { 23 | "inputs": [ 24 | { 25 | "internalType": "address", 26 | "name": "owner", 27 | "type": "address" 28 | } 29 | ], 30 | "name": "nonces", 31 | "outputs": [ 32 | { 33 | "internalType": "uint256", 34 | "name": "", 35 | "type": "uint256" 36 | } 37 | ], 38 | "stateMutability": "view", 39 | "type": "function" 40 | }, 41 | { 42 | "inputs": [ 43 | { 44 | "internalType": "address", 45 | "name": "owner", 46 | "type": "address" 47 | }, 48 | { 49 | "internalType": "uint192", 50 | "name": "key", 51 | "type": "uint192" 52 | } 53 | ], 54 | "name": "nonces", 55 | "outputs": [ 56 | { 57 | "internalType": "uint256", 58 | "name": "", 59 | "type": "uint256" 60 | } 61 | ], 62 | "stateMutability": "view", 63 | "type": "function" 64 | } 65 | ], 66 | "bytecode": "0x", 67 | "deployedBytecode": "0x", 68 | "linkReferences": {}, 69 | "deployedLinkReferences": {} 70 | } 71 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/Multicall.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.1) (utils/Multicall.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {Address} from "./Address.sol"; 7 | import {Context} from "./Context.sol"; 8 | 9 | /** 10 | * @dev Provides a function to batch together multiple calls in a single external call. 11 | * 12 | * Consider any assumption about calldata validation performed by the sender may be violated if it's not especially 13 | * careful about sending transactions invoking {multicall}. For example, a relay address that filters function 14 | * selectors won't filter calls nested within a {multicall} operation. 15 | * 16 | * NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {_msgSender}). 17 | * If a non-canonical context is identified, the following self `delegatecall` appends the last bytes of `msg.data` 18 | * to the subcall. This makes it safe to use with {ERC2771Context}. Contexts that don't affect the resolution of 19 | * {_msgSender} are not propagated to subcalls. 20 | */ 21 | abstract contract Multicall is Context { 22 | /** 23 | * @dev Receives and executes a batch of function calls on this contract. 24 | * @custom:oz-upgrades-unsafe-allow-reachable delegatecall 25 | */ 26 | function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) { 27 | bytes memory context = msg.sender == _msgSender() 28 | ? new bytes(0) 29 | : msg.data[msg.data.length - _contextSuffixLength():]; 30 | 31 | results = new bytes[](data.length); 32 | for (uint256 i = 0; i < data.length; i++) { 33 | results[i] = Address.functionDelegateCall(address(this), bytes.concat(data[i], context)); 34 | } 35 | return results; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /frontend-web3-daap/public/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 12 | 13 | 17 | 18 | 27 | React App 28 | 29 | 30 | 31 |
32 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.2.0) (proxy/ERC1967/ERC1967Proxy.sol) 3 | 4 | pragma solidity ^0.8.22; 5 | 6 | import {Proxy} from "../Proxy.sol"; 7 | import {ERC1967Utils} from "./ERC1967Utils.sol"; 8 | 9 | /** 10 | * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an 11 | * implementation address that can be changed. This address is stored in storage in the location specified by 12 | * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967], so that it doesn't conflict with the storage layout of the 13 | * implementation behind the proxy. 14 | */ 15 | contract ERC1967Proxy is Proxy { 16 | /** 17 | * @dev Initializes the upgradeable proxy with an initial implementation specified by `implementation`. 18 | * 19 | * If `_data` is nonempty, it's used as data in a delegate call to `implementation`. This will typically be an 20 | * encoded function call, and allows initializing the storage of the proxy like a Solidity constructor. 21 | * 22 | * Requirements: 23 | * 24 | * - If `data` is empty, `msg.value` must be zero. 25 | */ 26 | constructor(address implementation, bytes memory _data) payable { 27 | ERC1967Utils.upgradeToAndCall(implementation, _data); 28 | } 29 | 30 | /** 31 | * @dev Returns the current implementation address. 32 | * 33 | * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using 34 | * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. 35 | * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc` 36 | */ 37 | function _implementation() internal view virtual override returns (address) { 38 | return ERC1967Utils.getImplementation(); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/EIP712.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "EIP712", 4 | "sourceName": "contracts/utils/cryptography/EIP712.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "InvalidShortString", 9 | "type": "error" 10 | }, 11 | { 12 | "inputs": [ 13 | { 14 | "internalType": "string", 15 | "name": "str", 16 | "type": "string" 17 | } 18 | ], 19 | "name": "StringTooLong", 20 | "type": "error" 21 | }, 22 | { 23 | "anonymous": false, 24 | "inputs": [], 25 | "name": "EIP712DomainChanged", 26 | "type": "event" 27 | }, 28 | { 29 | "inputs": [], 30 | "name": "eip712Domain", 31 | "outputs": [ 32 | { 33 | "internalType": "bytes1", 34 | "name": "fields", 35 | "type": "bytes1" 36 | }, 37 | { 38 | "internalType": "string", 39 | "name": "name", 40 | "type": "string" 41 | }, 42 | { 43 | "internalType": "string", 44 | "name": "version", 45 | "type": "string" 46 | }, 47 | { 48 | "internalType": "uint256", 49 | "name": "chainId", 50 | "type": "uint256" 51 | }, 52 | { 53 | "internalType": "address", 54 | "name": "verifyingContract", 55 | "type": "address" 56 | }, 57 | { 58 | "internalType": "bytes32", 59 | "name": "salt", 60 | "type": "bytes32" 61 | }, 62 | { 63 | "internalType": "uint256[]", 64 | "name": "extensions", 65 | "type": "uint256[]" 66 | } 67 | ], 68 | "stateMutability": "view", 69 | "type": "function" 70 | } 71 | ], 72 | "bytecode": "0x", 73 | "deployedBytecode": "0x", 74 | "linkReferences": {}, 75 | "deployedLinkReferences": {} 76 | } 77 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/ITransparentUpgradeableProxy.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "ITransparentUpgradeableProxy", 4 | "sourceName": "contracts/proxy/transparent/TransparentUpgradeableProxy.sol", 5 | "abi": [ 6 | { 7 | "anonymous": false, 8 | "inputs": [ 9 | { 10 | "indexed": false, 11 | "internalType": "address", 12 | "name": "previousAdmin", 13 | "type": "address" 14 | }, 15 | { 16 | "indexed": false, 17 | "internalType": "address", 18 | "name": "newAdmin", 19 | "type": "address" 20 | } 21 | ], 22 | "name": "AdminChanged", 23 | "type": "event" 24 | }, 25 | { 26 | "anonymous": false, 27 | "inputs": [ 28 | { 29 | "indexed": true, 30 | "internalType": "address", 31 | "name": "beacon", 32 | "type": "address" 33 | } 34 | ], 35 | "name": "BeaconUpgraded", 36 | "type": "event" 37 | }, 38 | { 39 | "anonymous": false, 40 | "inputs": [ 41 | { 42 | "indexed": true, 43 | "internalType": "address", 44 | "name": "implementation", 45 | "type": "address" 46 | } 47 | ], 48 | "name": "Upgraded", 49 | "type": "event" 50 | }, 51 | { 52 | "inputs": [ 53 | { 54 | "internalType": "address", 55 | "name": "newImplementation", 56 | "type": "address" 57 | }, 58 | { 59 | "internalType": "bytes", 60 | "name": "data", 61 | "type": "bytes" 62 | } 63 | ], 64 | "name": "upgradeToAndCall", 65 | "outputs": [], 66 | "stateMutability": "payable", 67 | "type": "function" 68 | } 69 | ], 70 | "bytecode": "0x", 71 | "deployedBytecode": "0x", 72 | "linkReferences": {}, 73 | "deployedLinkReferences": {} 74 | } 75 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/extensions/ERC721Votes.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721Votes.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC721} from "../ERC721.sol"; 7 | import {Votes} from "../../../governance/utils/Votes.sol"; 8 | 9 | /** 10 | * @dev Extension of ERC-721 to support voting and delegation as implemented by {Votes}, where each individual NFT counts 11 | * as 1 vote unit. 12 | * 13 | * Tokens do not count as votes until they are delegated, because votes must be tracked which incurs an additional cost 14 | * on every transfer. Token holders can either delegate to a trusted representative who will decide how to make use of 15 | * the votes in governance decisions, or they can delegate to themselves to be their own representative. 16 | */ 17 | abstract contract ERC721Votes is ERC721, Votes { 18 | /** 19 | * @dev See {ERC721-_update}. Adjusts votes when tokens are transferred. 20 | * 21 | * Emits a {IVotes-DelegateVotesChanged} event. 22 | */ 23 | function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) { 24 | address previousOwner = super._update(to, tokenId, auth); 25 | 26 | _transferVotingUnits(previousOwner, to, 1); 27 | 28 | return previousOwner; 29 | } 30 | 31 | /** 32 | * @dev Returns the balance of `account`. 33 | * 34 | * WARNING: Overriding this function will likely result in incorrect vote tracking. 35 | */ 36 | function _getVotingUnits(address account) internal view virtual override returns (uint256) { 37 | return balanceOf(account); 38 | } 39 | 40 | /** 41 | * @dev See {ERC721-_increaseBalance}. We need that to account tokens that were minted in batch. 42 | */ 43 | function _increaseBalance(address account, uint128 amount) internal virtual override { 44 | super._increaseBalance(account, amount); 45 | _transferVotingUnits(address(0), account, amount); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/SafeCast.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "SafeCast", 4 | "sourceName": "contracts/utils/math/SafeCast.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "uint8", 10 | "name": "bits", 11 | "type": "uint8" 12 | }, 13 | { 14 | "internalType": "int256", 15 | "name": "value", 16 | "type": "int256" 17 | } 18 | ], 19 | "name": "SafeCastOverflowedIntDowncast", 20 | "type": "error" 21 | }, 22 | { 23 | "inputs": [ 24 | { 25 | "internalType": "int256", 26 | "name": "value", 27 | "type": "int256" 28 | } 29 | ], 30 | "name": "SafeCastOverflowedIntToUint", 31 | "type": "error" 32 | }, 33 | { 34 | "inputs": [ 35 | { 36 | "internalType": "uint8", 37 | "name": "bits", 38 | "type": "uint8" 39 | }, 40 | { 41 | "internalType": "uint256", 42 | "name": "value", 43 | "type": "uint256" 44 | } 45 | ], 46 | "name": "SafeCastOverflowedUintDowncast", 47 | "type": "error" 48 | }, 49 | { 50 | "inputs": [ 51 | { 52 | "internalType": "uint256", 53 | "name": "value", 54 | "type": "uint256" 55 | } 56 | ], 57 | "name": "SafeCastOverflowedUintToInt", 58 | "type": "error" 59 | } 60 | ], 61 | "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220badeeae4eba56ac4f76f97c7f40be9b269c0f596e7bf697d20fd59b391cb3e8064736f6c63430008180033", 62 | "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220badeeae4eba56ac4f76f97c7f40be9b269c0f596e7bf697d20fd59b391cb3e8064736f6c63430008180033", 63 | "linkReferences": {}, 64 | "deployedLinkReferences": {} 65 | } 66 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/CAIP2.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.2.0) (utils/CAIP2.sol) 3 | 4 | pragma solidity ^0.8.24; 5 | 6 | import {Bytes} from "./Bytes.sol"; 7 | import {Strings} from "./Strings.sol"; 8 | 9 | /** 10 | * @dev Helper library to format and parse CAIP-2 identifiers 11 | * 12 | * https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-2.md[CAIP-2] defines chain identifiers as: 13 | * chain_id: namespace + ":" + reference 14 | * namespace: [-a-z0-9]{3,8} 15 | * reference: [-_a-zA-Z0-9]{1,32} 16 | * 17 | * WARNING: In some cases, multiple CAIP-2 identifiers may all be valid representation of a single chain. 18 | * For EVM chains, it is recommended to use `eip155:xxx` as the canonical representation (where `xxx` is 19 | * the EIP-155 chain id). Consider the possible ambiguity when processing CAIP-2 identifiers or when using them 20 | * in the context of hashes. 21 | */ 22 | library CAIP2 { 23 | using Strings for uint256; 24 | using Bytes for bytes; 25 | 26 | /// @dev Return the CAIP-2 identifier for the current (local) chain. 27 | function local() internal view returns (string memory) { 28 | return format("eip155", block.chainid.toString()); 29 | } 30 | 31 | /** 32 | * @dev Return the CAIP-2 identifier for a given namespace and reference. 33 | * 34 | * NOTE: This function does not verify that the inputs are properly formatted. 35 | */ 36 | function format(string memory namespace, string memory ref) internal pure returns (string memory) { 37 | return string.concat(namespace, ":", ref); 38 | } 39 | 40 | /** 41 | * @dev Parse a CAIP-2 identifier into its components. 42 | * 43 | * NOTE: This function does not verify that the CAIP-2 input is properly formatted. 44 | */ 45 | function parse(string memory caip2) internal pure returns (string memory namespace, string memory ref) { 46 | bytes memory buffer = bytes(caip2); 47 | 48 | uint256 pos = buffer.indexOf(":"); 49 | return (string(buffer.slice(0, pos)), string(buffer.slice(pos + 1))); 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/utils/ERC721Utils.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IERC721Receiver} from "../IERC721Receiver.sol"; 7 | import {IERC721Errors} from "../../../interfaces/draft-IERC6093.sol"; 8 | 9 | /** 10 | * @dev Library that provide common ERC-721 utility functions. 11 | * 12 | * See https://eips.ethereum.org/EIPS/eip-721[ERC-721]. 13 | * 14 | * _Available since v5.1._ 15 | */ 16 | library ERC721Utils { 17 | /** 18 | * @dev Performs an acceptance check for the provided `operator` by calling {IERC721-onERC721Received} 19 | * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). 20 | * 21 | * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA). 22 | * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept 23 | * the transfer. 24 | */ 25 | function checkOnERC721Received( 26 | address operator, 27 | address from, 28 | address to, 29 | uint256 tokenId, 30 | bytes memory data 31 | ) internal { 32 | if (to.code.length > 0) { 33 | try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) { 34 | if (retval != IERC721Receiver.onERC721Received.selector) { 35 | // Token rejected 36 | revert IERC721Errors.ERC721InvalidReceiver(to); 37 | } 38 | } catch (bytes memory reason) { 39 | if (reason.length == 0) { 40 | // non-IERC721Receiver implementer 41 | revert IERC721Errors.ERC721InvalidReceiver(to); 42 | } else { 43 | assembly ("memory-safe") { 44 | revert(add(32, reason), mload(reason)) 45 | } 46 | } 47 | } 48 | } 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/Ownable.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "Ownable", 4 | "sourceName": "contracts/access/Ownable.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "owner", 11 | "type": "address" 12 | } 13 | ], 14 | "name": "OwnableInvalidOwner", 15 | "type": "error" 16 | }, 17 | { 18 | "inputs": [ 19 | { 20 | "internalType": "address", 21 | "name": "account", 22 | "type": "address" 23 | } 24 | ], 25 | "name": "OwnableUnauthorizedAccount", 26 | "type": "error" 27 | }, 28 | { 29 | "anonymous": false, 30 | "inputs": [ 31 | { 32 | "indexed": true, 33 | "internalType": "address", 34 | "name": "previousOwner", 35 | "type": "address" 36 | }, 37 | { 38 | "indexed": true, 39 | "internalType": "address", 40 | "name": "newOwner", 41 | "type": "address" 42 | } 43 | ], 44 | "name": "OwnershipTransferred", 45 | "type": "event" 46 | }, 47 | { 48 | "inputs": [], 49 | "name": "owner", 50 | "outputs": [ 51 | { 52 | "internalType": "address", 53 | "name": "", 54 | "type": "address" 55 | } 56 | ], 57 | "stateMutability": "view", 58 | "type": "function" 59 | }, 60 | { 61 | "inputs": [], 62 | "name": "renounceOwnership", 63 | "outputs": [], 64 | "stateMutability": "nonpayable", 65 | "type": "function" 66 | }, 67 | { 68 | "inputs": [ 69 | { 70 | "internalType": "address", 71 | "name": "newOwner", 72 | "type": "address" 73 | } 74 | ], 75 | "name": "transferOwnership", 76 | "outputs": [], 77 | "stateMutability": "nonpayable", 78 | "type": "function" 79 | } 80 | ], 81 | "bytecode": "0x", 82 | "deployedBytecode": "0x", 83 | "linkReferences": {}, 84 | "deployedLinkReferences": {} 85 | } 86 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.2.0) (proxy/transparent/ProxyAdmin.sol) 3 | 4 | pragma solidity ^0.8.22; 5 | 6 | import {ITransparentUpgradeableProxy} from "./TransparentUpgradeableProxy.sol"; 7 | import {Ownable} from "../../access/Ownable.sol"; 8 | 9 | /** 10 | * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an 11 | * explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}. 12 | */ 13 | contract ProxyAdmin is Ownable { 14 | /** 15 | * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgrade(address,address)` 16 | * and `upgradeAndCall(address,address,bytes)` are present, and `upgrade` must be used if no function should be called, 17 | * while `upgradeAndCall` will invoke the `receive` function if the third argument is the empty byte string. 18 | * If the getter returns `"5.0.0"`, only `upgradeAndCall(address,address,bytes)` is present, and the third argument must 19 | * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function 20 | * during an upgrade. 21 | */ 22 | string public constant UPGRADE_INTERFACE_VERSION = "5.0.0"; 23 | 24 | /** 25 | * @dev Sets the initial owner who can perform upgrades. 26 | */ 27 | constructor(address initialOwner) Ownable(initialOwner) {} 28 | 29 | /** 30 | * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation. 31 | * See {TransparentUpgradeableProxy-_dispatchUpgradeToAndCall}. 32 | * 33 | * Requirements: 34 | * 35 | * - This contract must be the admin of `proxy`. 36 | * - If `data` is empty, `msg.value` must be zero. 37 | */ 38 | function upgradeAndCall( 39 | ITransparentUpgradeableProxy proxy, 40 | address implementation, 41 | bytes memory data 42 | ) public payable virtual onlyOwner { 43 | proxy.upgradeToAndCall{value: msg.value}(implementation, data); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC2612.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC2612", 4 | "sourceName": "contracts/interfaces/IERC2612.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "DOMAIN_SEPARATOR", 9 | "outputs": [ 10 | { 11 | "internalType": "bytes32", 12 | "name": "", 13 | "type": "bytes32" 14 | } 15 | ], 16 | "stateMutability": "view", 17 | "type": "function" 18 | }, 19 | { 20 | "inputs": [ 21 | { 22 | "internalType": "address", 23 | "name": "owner", 24 | "type": "address" 25 | } 26 | ], 27 | "name": "nonces", 28 | "outputs": [ 29 | { 30 | "internalType": "uint256", 31 | "name": "", 32 | "type": "uint256" 33 | } 34 | ], 35 | "stateMutability": "view", 36 | "type": "function" 37 | }, 38 | { 39 | "inputs": [ 40 | { 41 | "internalType": "address", 42 | "name": "owner", 43 | "type": "address" 44 | }, 45 | { 46 | "internalType": "address", 47 | "name": "spender", 48 | "type": "address" 49 | }, 50 | { 51 | "internalType": "uint256", 52 | "name": "value", 53 | "type": "uint256" 54 | }, 55 | { 56 | "internalType": "uint256", 57 | "name": "deadline", 58 | "type": "uint256" 59 | }, 60 | { 61 | "internalType": "uint8", 62 | "name": "v", 63 | "type": "uint8" 64 | }, 65 | { 66 | "internalType": "bytes32", 67 | "name": "r", 68 | "type": "bytes32" 69 | }, 70 | { 71 | "internalType": "bytes32", 72 | "name": "s", 73 | "type": "bytes32" 74 | } 75 | ], 76 | "name": "permit", 77 | "outputs": [], 78 | "stateMutability": "nonpayable", 79 | "type": "function" 80 | } 81 | ], 82 | "bytecode": "0x", 83 | "deployedBytecode": "0x", 84 | "linkReferences": {}, 85 | "deployedLinkReferences": {} 86 | } 87 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/Panic.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | /** 7 | * @dev Helper library for emitting standardized panic codes. 8 | * 9 | * ```solidity 10 | * contract Example { 11 | * using Panic for uint256; 12 | * 13 | * // Use any of the declared internal constants 14 | * function foo() { Panic.GENERIC.panic(); } 15 | * 16 | * // Alternatively 17 | * function foo() { Panic.panic(Panic.GENERIC); } 18 | * } 19 | * ``` 20 | * 21 | * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil]. 22 | * 23 | * _Available since v5.1._ 24 | */ 25 | // slither-disable-next-line unused-state 26 | library Panic { 27 | /// @dev generic / unspecified error 28 | uint256 internal constant GENERIC = 0x00; 29 | /// @dev used by the assert() builtin 30 | uint256 internal constant ASSERT = 0x01; 31 | /// @dev arithmetic underflow or overflow 32 | uint256 internal constant UNDER_OVERFLOW = 0x11; 33 | /// @dev division or modulo by zero 34 | uint256 internal constant DIVISION_BY_ZERO = 0x12; 35 | /// @dev enum conversion error 36 | uint256 internal constant ENUM_CONVERSION_ERROR = 0x21; 37 | /// @dev invalid encoding in storage 38 | uint256 internal constant STORAGE_ENCODING_ERROR = 0x22; 39 | /// @dev empty array pop 40 | uint256 internal constant EMPTY_ARRAY_POP = 0x31; 41 | /// @dev array out of bounds access 42 | uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32; 43 | /// @dev resource error (too large allocation or too large array) 44 | uint256 internal constant RESOURCE_ERROR = 0x41; 45 | /// @dev calling invalid internal function 46 | uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51; 47 | 48 | /// @dev Reverts with a panic code. Recommended to use with 49 | /// the internal constants with predefined codes. 50 | function panic(uint256 code) internal pure { 51 | assembly ("memory-safe") { 52 | mstore(0x00, 0x4e487b71) 53 | mstore(0x20, code) 54 | revert(0x1c, 0x24) 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC20Permit.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC20Permit", 4 | "sourceName": "contracts/token/ERC20/extensions/IERC20Permit.sol", 5 | "abi": [ 6 | { 7 | "inputs": [], 8 | "name": "DOMAIN_SEPARATOR", 9 | "outputs": [ 10 | { 11 | "internalType": "bytes32", 12 | "name": "", 13 | "type": "bytes32" 14 | } 15 | ], 16 | "stateMutability": "view", 17 | "type": "function" 18 | }, 19 | { 20 | "inputs": [ 21 | { 22 | "internalType": "address", 23 | "name": "owner", 24 | "type": "address" 25 | } 26 | ], 27 | "name": "nonces", 28 | "outputs": [ 29 | { 30 | "internalType": "uint256", 31 | "name": "", 32 | "type": "uint256" 33 | } 34 | ], 35 | "stateMutability": "view", 36 | "type": "function" 37 | }, 38 | { 39 | "inputs": [ 40 | { 41 | "internalType": "address", 42 | "name": "owner", 43 | "type": "address" 44 | }, 45 | { 46 | "internalType": "address", 47 | "name": "spender", 48 | "type": "address" 49 | }, 50 | { 51 | "internalType": "uint256", 52 | "name": "value", 53 | "type": "uint256" 54 | }, 55 | { 56 | "internalType": "uint256", 57 | "name": "deadline", 58 | "type": "uint256" 59 | }, 60 | { 61 | "internalType": "uint8", 62 | "name": "v", 63 | "type": "uint8" 64 | }, 65 | { 66 | "internalType": "bytes32", 67 | "name": "r", 68 | "type": "bytes32" 69 | }, 70 | { 71 | "internalType": "bytes32", 72 | "name": "s", 73 | "type": "bytes32" 74 | } 75 | ], 76 | "name": "permit", 77 | "outputs": [], 78 | "stateMutability": "nonpayable", 79 | "type": "function" 80 | } 81 | ], 82 | "bytecode": "0x", 83 | "deployedBytecode": "0x", 84 | "linkReferences": {}, 85 | "deployedLinkReferences": {} 86 | } 87 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/finance/VestingWalletCliff.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (finance/VestingWalletCliff.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {SafeCast} from "../utils/math/SafeCast.sol"; 7 | import {VestingWallet} from "./VestingWallet.sol"; 8 | 9 | /** 10 | * @dev Extension of {VestingWallet} that adds a cliff to the vesting schedule. 11 | * 12 | * _Available since v5.1._ 13 | */ 14 | abstract contract VestingWalletCliff is VestingWallet { 15 | using SafeCast for *; 16 | 17 | uint64 private immutable _cliff; 18 | 19 | /// @dev The specified cliff duration is larger than the vesting duration. 20 | error InvalidCliffDuration(uint64 cliffSeconds, uint64 durationSeconds); 21 | 22 | /** 23 | * @dev Set the duration of the cliff, in seconds. The cliff starts vesting schedule (see {VestingWallet}'s 24 | * constructor) and ends `cliffSeconds` later. 25 | */ 26 | constructor(uint64 cliffSeconds) { 27 | if (cliffSeconds > duration()) { 28 | revert InvalidCliffDuration(cliffSeconds, duration().toUint64()); 29 | } 30 | _cliff = start().toUint64() + cliffSeconds; 31 | } 32 | 33 | /** 34 | * @dev Getter for the cliff timestamp. 35 | */ 36 | function cliff() public view virtual returns (uint256) { 37 | return _cliff; 38 | } 39 | 40 | /** 41 | * @dev Virtual implementation of the vesting formula. This returns the amount vested, as a function of time, for 42 | * an asset given its total historical allocation. Returns 0 if the {cliff} timestamp is not met. 43 | * 44 | * IMPORTANT: The cliff not only makes the schedule return 0, but it also ignores every possible side 45 | * effect from calling the inherited implementation (i.e. `super._vestingSchedule`). Carefully consider 46 | * this caveat if the overridden implementation of this function has any (e.g. writing to memory or reverting). 47 | */ 48 | function _vestingSchedule( 49 | uint256 totalAllocation, 50 | uint64 timestamp 51 | ) internal view virtual override returns (uint256) { 52 | return timestamp < cliff() ? 0 : super._vestingSchedule(totalAllocation, timestamp); 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC3156FlashLender.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC3156FlashLender", 4 | "sourceName": "contracts/interfaces/IERC3156FlashLender.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "token", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "uint256", 15 | "name": "amount", 16 | "type": "uint256" 17 | } 18 | ], 19 | "name": "flashFee", 20 | "outputs": [ 21 | { 22 | "internalType": "uint256", 23 | "name": "", 24 | "type": "uint256" 25 | } 26 | ], 27 | "stateMutability": "view", 28 | "type": "function" 29 | }, 30 | { 31 | "inputs": [ 32 | { 33 | "internalType": "contract IERC3156FlashBorrower", 34 | "name": "receiver", 35 | "type": "address" 36 | }, 37 | { 38 | "internalType": "address", 39 | "name": "token", 40 | "type": "address" 41 | }, 42 | { 43 | "internalType": "uint256", 44 | "name": "amount", 45 | "type": "uint256" 46 | }, 47 | { 48 | "internalType": "bytes", 49 | "name": "data", 50 | "type": "bytes" 51 | } 52 | ], 53 | "name": "flashLoan", 54 | "outputs": [ 55 | { 56 | "internalType": "bool", 57 | "name": "", 58 | "type": "bool" 59 | } 60 | ], 61 | "stateMutability": "nonpayable", 62 | "type": "function" 63 | }, 64 | { 65 | "inputs": [ 66 | { 67 | "internalType": "address", 68 | "name": "token", 69 | "type": "address" 70 | } 71 | ], 72 | "name": "maxFlashLoan", 73 | "outputs": [ 74 | { 75 | "internalType": "uint256", 76 | "name": "", 77 | "type": "uint256" 78 | } 79 | ], 80 | "stateMutability": "view", 81 | "type": "function" 82 | } 83 | ], 84 | "bytecode": "0x", 85 | "deployedBytecode": "0x", 86 | "linkReferences": {}, 87 | "deployedLinkReferences": {} 88 | } 89 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IAccountExecute.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IAccountExecute", 4 | "sourceName": "contracts/interfaces/draft-IERC4337.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "components": [ 10 | { 11 | "internalType": "address", 12 | "name": "sender", 13 | "type": "address" 14 | }, 15 | { 16 | "internalType": "uint256", 17 | "name": "nonce", 18 | "type": "uint256" 19 | }, 20 | { 21 | "internalType": "bytes", 22 | "name": "initCode", 23 | "type": "bytes" 24 | }, 25 | { 26 | "internalType": "bytes", 27 | "name": "callData", 28 | "type": "bytes" 29 | }, 30 | { 31 | "internalType": "bytes32", 32 | "name": "accountGasLimits", 33 | "type": "bytes32" 34 | }, 35 | { 36 | "internalType": "uint256", 37 | "name": "preVerificationGas", 38 | "type": "uint256" 39 | }, 40 | { 41 | "internalType": "bytes32", 42 | "name": "gasFees", 43 | "type": "bytes32" 44 | }, 45 | { 46 | "internalType": "bytes", 47 | "name": "paymasterAndData", 48 | "type": "bytes" 49 | }, 50 | { 51 | "internalType": "bytes", 52 | "name": "signature", 53 | "type": "bytes" 54 | } 55 | ], 56 | "internalType": "struct PackedUserOperation", 57 | "name": "userOp", 58 | "type": "tuple" 59 | }, 60 | { 61 | "internalType": "bytes32", 62 | "name": "userOpHash", 63 | "type": "bytes32" 64 | } 65 | ], 66 | "name": "executeUserOp", 67 | "outputs": [], 68 | "stateMutability": "nonpayable", 69 | "type": "function" 70 | } 71 | ], 72 | "bytecode": "0x", 73 | "deployedBytecode": "0x", 74 | "linkReferences": {}, 75 | "deployedLinkReferences": {} 76 | } 77 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/structs/BitMaps.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/BitMaps.sol) 3 | pragma solidity ^0.8.20; 4 | 5 | /** 6 | * @dev Library for managing uint256 to bool mapping in a compact and efficient way, provided the keys are sequential. 7 | * Largely inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor]. 8 | * 9 | * BitMaps pack 256 booleans across each bit of a single 256-bit slot of `uint256` type. 10 | * Hence booleans corresponding to 256 _sequential_ indices would only consume a single slot, 11 | * unlike the regular `bool` which would consume an entire slot for a single value. 12 | * 13 | * This results in gas savings in two ways: 14 | * 15 | * - Setting a zero value to non-zero only once every 256 times 16 | * - Accessing the same warm slot for every 256 _sequential_ indices 17 | */ 18 | library BitMaps { 19 | struct BitMap { 20 | mapping(uint256 bucket => uint256) _data; 21 | } 22 | 23 | /** 24 | * @dev Returns whether the bit at `index` is set. 25 | */ 26 | function get(BitMap storage bitmap, uint256 index) internal view returns (bool) { 27 | uint256 bucket = index >> 8; 28 | uint256 mask = 1 << (index & 0xff); 29 | return bitmap._data[bucket] & mask != 0; 30 | } 31 | 32 | /** 33 | * @dev Sets the bit at `index` to the boolean `value`. 34 | */ 35 | function setTo(BitMap storage bitmap, uint256 index, bool value) internal { 36 | if (value) { 37 | set(bitmap, index); 38 | } else { 39 | unset(bitmap, index); 40 | } 41 | } 42 | 43 | /** 44 | * @dev Sets the bit at `index`. 45 | */ 46 | function set(BitMap storage bitmap, uint256 index) internal { 47 | uint256 bucket = index >> 8; 48 | uint256 mask = 1 << (index & 0xff); 49 | bitmap._data[bucket] |= mask; 50 | } 51 | 52 | /** 53 | * @dev Unsets the bit at `index`. 54 | */ 55 | function unset(BitMap storage bitmap, uint256 index) internal { 56 | uint256 bucket = index >> 8; 57 | uint256 mask = 1 << (index & 0xff); 58 | bitmap._data[bucket] &= ~mask; 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuardTransient.sol) 3 | 4 | pragma solidity ^0.8.24; 5 | 6 | import {TransientSlot} from "./TransientSlot.sol"; 7 | 8 | /** 9 | * @dev Variant of {ReentrancyGuard} that uses transient storage. 10 | * 11 | * NOTE: This variant only works on networks where EIP-1153 is available. 12 | * 13 | * _Available since v5.1._ 14 | */ 15 | abstract contract ReentrancyGuardTransient { 16 | using TransientSlot for *; 17 | 18 | // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff)) 19 | bytes32 private constant REENTRANCY_GUARD_STORAGE = 20 | 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; 21 | 22 | /** 23 | * @dev Unauthorized reentrant call. 24 | */ 25 | error ReentrancyGuardReentrantCall(); 26 | 27 | /** 28 | * @dev Prevents a contract from calling itself, directly or indirectly. 29 | * Calling a `nonReentrant` function from another `nonReentrant` 30 | * function is not supported. It is possible to prevent this from happening 31 | * by making the `nonReentrant` function external, and making it call a 32 | * `private` function that does the actual work. 33 | */ 34 | modifier nonReentrant() { 35 | _nonReentrantBefore(); 36 | _; 37 | _nonReentrantAfter(); 38 | } 39 | 40 | function _nonReentrantBefore() private { 41 | // On the first call to nonReentrant, _status will be NOT_ENTERED 42 | if (_reentrancyGuardEntered()) { 43 | revert ReentrancyGuardReentrantCall(); 44 | } 45 | 46 | // Any calls to nonReentrant after this point will fail 47 | REENTRANCY_GUARD_STORAGE.asBoolean().tstore(true); 48 | } 49 | 50 | function _nonReentrantAfter() private { 51 | REENTRANCY_GUARD_STORAGE.asBoolean().tstore(false); 52 | } 53 | 54 | /** 55 | * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a 56 | * `nonReentrant` function in the call stack. 57 | */ 58 | function _reentrancyGuardEntered() internal view returns (bool) { 59 | return REENTRANCY_GUARD_STORAGE.asBoolean().tload(); 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/governance/extensions/GovernorVotes.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (governance/extensions/GovernorVotes.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {Governor} from "../Governor.sol"; 7 | import {IVotes} from "../utils/IVotes.sol"; 8 | import {IERC5805} from "../../interfaces/IERC5805.sol"; 9 | import {SafeCast} from "../../utils/math/SafeCast.sol"; 10 | import {Time} from "../../utils/types/Time.sol"; 11 | 12 | /** 13 | * @dev Extension of {Governor} for voting weight extraction from an {ERC20Votes} token, or since v4.5 an {ERC721Votes} 14 | * token. 15 | */ 16 | abstract contract GovernorVotes is Governor { 17 | IERC5805 private immutable _token; 18 | 19 | constructor(IVotes tokenAddress) { 20 | _token = IERC5805(address(tokenAddress)); 21 | } 22 | 23 | /** 24 | * @dev The token that voting power is sourced from. 25 | */ 26 | function token() public view virtual returns (IERC5805) { 27 | return _token; 28 | } 29 | 30 | /** 31 | * @dev Clock (as specified in ERC-6372) is set to match the token's clock. Fallback to block numbers if the token 32 | * does not implement ERC-6372. 33 | */ 34 | function clock() public view virtual override returns (uint48) { 35 | try token().clock() returns (uint48 timepoint) { 36 | return timepoint; 37 | } catch { 38 | return Time.blockNumber(); 39 | } 40 | } 41 | 42 | /** 43 | * @dev Machine-readable description of the clock as specified in ERC-6372. 44 | */ 45 | // solhint-disable-next-line func-name-mixedcase 46 | function CLOCK_MODE() public view virtual override returns (string memory) { 47 | try token().CLOCK_MODE() returns (string memory clockmode) { 48 | return clockmode; 49 | } catch { 50 | return "mode=blocknumber&from=default"; 51 | } 52 | } 53 | 54 | /** 55 | * Read the voting weight from the token's built in snapshot mechanism (see {Governor-_getVotes}). 56 | */ 57 | function _getVotes( 58 | address account, 59 | uint256 timepoint, 60 | bytes memory /*params*/ 61 | ) internal view virtual override returns (uint256) { 62 | return token().getPastVotes(account, timepoint); 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC1155/extensions/ERC1155URIStorage.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/extensions/ERC1155URIStorage.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {Strings} from "../../../utils/Strings.sol"; 7 | import {ERC1155} from "../ERC1155.sol"; 8 | 9 | /** 10 | * @dev ERC-1155 token with storage based token URI management. 11 | * Inspired by the {ERC721URIStorage} extension 12 | */ 13 | abstract contract ERC1155URIStorage is ERC1155 { 14 | using Strings for uint256; 15 | 16 | // Optional base URI 17 | string private _baseURI = ""; 18 | 19 | // Optional mapping for token URIs 20 | mapping(uint256 tokenId => string) private _tokenURIs; 21 | 22 | /** 23 | * @dev See {IERC1155MetadataURI-uri}. 24 | * 25 | * This implementation returns the concatenation of the `_baseURI` 26 | * and the token-specific uri if the latter is set 27 | * 28 | * This enables the following behaviors: 29 | * 30 | * - if `_tokenURIs[tokenId]` is set, then the result is the concatenation 31 | * of `_baseURI` and `_tokenURIs[tokenId]` (keep in mind that `_baseURI` 32 | * is empty per default); 33 | * 34 | * - if `_tokenURIs[tokenId]` is NOT set then we fallback to `super.uri()` 35 | * which in most cases will contain `ERC1155._uri`; 36 | * 37 | * - if `_tokenURIs[tokenId]` is NOT set, and if the parents do not have a 38 | * uri value set, then the result is empty. 39 | */ 40 | function uri(uint256 tokenId) public view virtual override returns (string memory) { 41 | string memory tokenURI = _tokenURIs[tokenId]; 42 | 43 | // If token URI is set, concatenate base URI and tokenURI (via string.concat). 44 | return bytes(tokenURI).length > 0 ? string.concat(_baseURI, tokenURI) : super.uri(tokenId); 45 | } 46 | 47 | /** 48 | * @dev Sets `tokenURI` as the tokenURI of `tokenId`. 49 | */ 50 | function _setURI(uint256 tokenId, string memory tokenURI) internal virtual { 51 | _tokenURIs[tokenId] = tokenURI; 52 | emit URI(uri(tokenId), tokenId); 53 | } 54 | 55 | /** 56 | * @dev Sets `baseURI` as the `_baseURI` for all tokens 57 | */ 58 | function _setBaseURI(string memory baseURI) internal virtual { 59 | _baseURI = baseURI; 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721URIStorage.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {ERC721} from "../ERC721.sol"; 7 | import {Strings} from "../../../utils/Strings.sol"; 8 | import {IERC4906} from "../../../interfaces/IERC4906.sol"; 9 | import {IERC165} from "../../../interfaces/IERC165.sol"; 10 | 11 | /** 12 | * @dev ERC-721 token with storage based token URI management. 13 | */ 14 | abstract contract ERC721URIStorage is IERC4906, ERC721 { 15 | using Strings for uint256; 16 | 17 | // Interface ID as defined in ERC-4906. This does not correspond to a traditional interface ID as ERC-4906 only 18 | // defines events and does not include any external function. 19 | bytes4 private constant ERC4906_INTERFACE_ID = bytes4(0x49064906); 20 | 21 | // Optional mapping for token URIs 22 | mapping(uint256 tokenId => string) private _tokenURIs; 23 | 24 | /** 25 | * @dev See {IERC165-supportsInterface} 26 | */ 27 | function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, IERC165) returns (bool) { 28 | return interfaceId == ERC4906_INTERFACE_ID || super.supportsInterface(interfaceId); 29 | } 30 | 31 | /** 32 | * @dev See {IERC721Metadata-tokenURI}. 33 | */ 34 | function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { 35 | _requireOwned(tokenId); 36 | 37 | string memory _tokenURI = _tokenURIs[tokenId]; 38 | string memory base = _baseURI(); 39 | 40 | // If there is no base URI, return the token URI. 41 | if (bytes(base).length == 0) { 42 | return _tokenURI; 43 | } 44 | // If both are set, concatenate the baseURI and tokenURI (via string.concat). 45 | if (bytes(_tokenURI).length > 0) { 46 | return string.concat(base, _tokenURI); 47 | } 48 | 49 | return super.tokenURI(tokenId); 50 | } 51 | 52 | /** 53 | * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. 54 | * 55 | * Emits {MetadataUpdate}. 56 | */ 57 | function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { 58 | _tokenURIs[tokenId] = _tokenURI; 59 | emit MetadataUpdate(tokenId); 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IEntryPointStake.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IEntryPointStake", 4 | "sourceName": "contracts/interfaces/draft-IERC4337.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "uint32", 10 | "name": "unstakeDelaySec", 11 | "type": "uint32" 12 | } 13 | ], 14 | "name": "addStake", 15 | "outputs": [], 16 | "stateMutability": "payable", 17 | "type": "function" 18 | }, 19 | { 20 | "inputs": [ 21 | { 22 | "internalType": "address", 23 | "name": "account", 24 | "type": "address" 25 | } 26 | ], 27 | "name": "balanceOf", 28 | "outputs": [ 29 | { 30 | "internalType": "uint256", 31 | "name": "", 32 | "type": "uint256" 33 | } 34 | ], 35 | "stateMutability": "view", 36 | "type": "function" 37 | }, 38 | { 39 | "inputs": [ 40 | { 41 | "internalType": "address", 42 | "name": "account", 43 | "type": "address" 44 | } 45 | ], 46 | "name": "depositTo", 47 | "outputs": [], 48 | "stateMutability": "payable", 49 | "type": "function" 50 | }, 51 | { 52 | "inputs": [], 53 | "name": "unlockStake", 54 | "outputs": [], 55 | "stateMutability": "nonpayable", 56 | "type": "function" 57 | }, 58 | { 59 | "inputs": [ 60 | { 61 | "internalType": "address payable", 62 | "name": "withdrawAddress", 63 | "type": "address" 64 | } 65 | ], 66 | "name": "withdrawStake", 67 | "outputs": [], 68 | "stateMutability": "nonpayable", 69 | "type": "function" 70 | }, 71 | { 72 | "inputs": [ 73 | { 74 | "internalType": "address payable", 75 | "name": "withdrawAddress", 76 | "type": "address" 77 | }, 78 | { 79 | "internalType": "uint256", 80 | "name": "withdrawAmount", 81 | "type": "uint256" 82 | } 83 | ], 84 | "name": "withdrawTo", 85 | "outputs": [], 86 | "stateMutability": "nonpayable", 87 | "type": "function" 88 | } 89 | ], 90 | "bytecode": "0x", 91 | "deployedBytecode": "0x", 92 | "linkReferences": {}, 93 | "deployedLinkReferences": {} 94 | } 95 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC20Errors.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC20Errors", 4 | "sourceName": "contracts/interfaces/draft-IERC6093.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "address", 10 | "name": "spender", 11 | "type": "address" 12 | }, 13 | { 14 | "internalType": "uint256", 15 | "name": "allowance", 16 | "type": "uint256" 17 | }, 18 | { 19 | "internalType": "uint256", 20 | "name": "needed", 21 | "type": "uint256" 22 | } 23 | ], 24 | "name": "ERC20InsufficientAllowance", 25 | "type": "error" 26 | }, 27 | { 28 | "inputs": [ 29 | { 30 | "internalType": "address", 31 | "name": "sender", 32 | "type": "address" 33 | }, 34 | { 35 | "internalType": "uint256", 36 | "name": "balance", 37 | "type": "uint256" 38 | }, 39 | { 40 | "internalType": "uint256", 41 | "name": "needed", 42 | "type": "uint256" 43 | } 44 | ], 45 | "name": "ERC20InsufficientBalance", 46 | "type": "error" 47 | }, 48 | { 49 | "inputs": [ 50 | { 51 | "internalType": "address", 52 | "name": "approver", 53 | "type": "address" 54 | } 55 | ], 56 | "name": "ERC20InvalidApprover", 57 | "type": "error" 58 | }, 59 | { 60 | "inputs": [ 61 | { 62 | "internalType": "address", 63 | "name": "receiver", 64 | "type": "address" 65 | } 66 | ], 67 | "name": "ERC20InvalidReceiver", 68 | "type": "error" 69 | }, 70 | { 71 | "inputs": [ 72 | { 73 | "internalType": "address", 74 | "name": "sender", 75 | "type": "address" 76 | } 77 | ], 78 | "name": "ERC20InvalidSender", 79 | "type": "error" 80 | }, 81 | { 82 | "inputs": [ 83 | { 84 | "internalType": "address", 85 | "name": "spender", 86 | "type": "address" 87 | } 88 | ], 89 | "name": "ERC20InvalidSpender", 90 | "type": "error" 91 | } 92 | ], 93 | "bytecode": "0x", 94 | "deployedBytecode": "0x", 95 | "linkReferences": {}, 96 | "deployedLinkReferences": {} 97 | } 98 | -------------------------------------------------------------------------------- /backend-smartcontract/src/nftticket-smartcontract.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity 0.8.28; 4 | 5 | //deployed at 0xcc953a40dfeb38d145710c43c1a9daec39dfa413 6 | 7 | import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol"; 8 | import "@openzeppelin/contracts/access/Ownable.sol"; 9 | contract TicketNFT is ERC721URIStorage, Ownable { 10 | uint256 public constant MINT_FEE = 0.001 ether; 11 | uint256 public constant MAX_TICKETS = 50; 12 | 13 | uint256 private _currentTokenId; 14 | address public lastBuyer; 15 | uint256 public lastTokenId; 16 | 17 | event TicketMinted(address indexed buyer, uint256 tokenId); 18 | 19 | constructor(string memory name, string memory symbol) ERC721(name, symbol) Ownable(msg.sender) {} 20 | 21 | function mintTicket(string memory uri) public payable { 22 | require(msg.value == MINT_FEE, "Incorrect fee"); 23 | require(_currentTokenId < MAX_TICKETS, "All tickets have been minted"); 24 | 25 | uint256 tokenId = _currentTokenId; 26 | _safeMint(msg.sender, tokenId); 27 | _setTokenURI(tokenId, uri); 28 | 29 | lastBuyer = msg.sender; 30 | lastTokenId = tokenId; 31 | 32 | _currentTokenId++; 33 | 34 | emit TicketMinted(msg.sender, tokenId); 35 | } 36 | 37 | function withdraw() external onlyOwner { 38 | uint256 balance = address(this).balance; 39 | require(balance > 0, "No funds to withdraw"); 40 | payable(owner()).transfer(balance); 41 | } 42 | 43 | function getCurrentTicketCount() external view returns (uint256) { 44 | return _currentTokenId; 45 | } 46 | 47 | function getLastBuyerInfo() external view returns (address buyer, uint256 tokenId) { 48 | return (lastBuyer, lastTokenId); 49 | } 50 | 51 | function _update( 52 | address to, 53 | uint256 tokenId, 54 | address auth 55 | ) internal virtual override returns (address) { 56 | address from = _ownerOf(tokenId); 57 | require(from == address(0), "NFT is non-transferable"); 58 | return super._update(to, tokenId, auth); 59 | } 60 | 61 | function getOwner() external view returns (address) { 62 | return owner(); 63 | } 64 | 65 | 66 | function tokenURI(uint256 tokenId) 67 | public 68 | view 69 | virtual 70 | override 71 | returns (string memory) 72 | { 73 | return super.tokenURI(tokenId); 74 | } 75 | } -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/build/contracts/IERC7579Hook.json: -------------------------------------------------------------------------------- 1 | { 2 | "_format": "hh-sol-artifact-1", 3 | "contractName": "IERC7579Hook", 4 | "sourceName": "contracts/interfaces/draft-IERC7579.sol", 5 | "abi": [ 6 | { 7 | "inputs": [ 8 | { 9 | "internalType": "uint256", 10 | "name": "moduleTypeId", 11 | "type": "uint256" 12 | } 13 | ], 14 | "name": "isModuleType", 15 | "outputs": [ 16 | { 17 | "internalType": "bool", 18 | "name": "", 19 | "type": "bool" 20 | } 21 | ], 22 | "stateMutability": "view", 23 | "type": "function" 24 | }, 25 | { 26 | "inputs": [ 27 | { 28 | "internalType": "bytes", 29 | "name": "data", 30 | "type": "bytes" 31 | } 32 | ], 33 | "name": "onInstall", 34 | "outputs": [], 35 | "stateMutability": "nonpayable", 36 | "type": "function" 37 | }, 38 | { 39 | "inputs": [ 40 | { 41 | "internalType": "bytes", 42 | "name": "data", 43 | "type": "bytes" 44 | } 45 | ], 46 | "name": "onUninstall", 47 | "outputs": [], 48 | "stateMutability": "nonpayable", 49 | "type": "function" 50 | }, 51 | { 52 | "inputs": [ 53 | { 54 | "internalType": "bytes", 55 | "name": "hookData", 56 | "type": "bytes" 57 | } 58 | ], 59 | "name": "postCheck", 60 | "outputs": [], 61 | "stateMutability": "nonpayable", 62 | "type": "function" 63 | }, 64 | { 65 | "inputs": [ 66 | { 67 | "internalType": "address", 68 | "name": "msgSender", 69 | "type": "address" 70 | }, 71 | { 72 | "internalType": "uint256", 73 | "name": "value", 74 | "type": "uint256" 75 | }, 76 | { 77 | "internalType": "bytes", 78 | "name": "msgData", 79 | "type": "bytes" 80 | } 81 | ], 82 | "name": "preCheck", 83 | "outputs": [ 84 | { 85 | "internalType": "bytes", 86 | "name": "hookData", 87 | "type": "bytes" 88 | } 89 | ], 90 | "stateMutability": "nonpayable", 91 | "type": "function" 92 | } 93 | ], 94 | "bytecode": "0x", 95 | "deployedBytecode": "0x", 96 | "linkReferences": {}, 97 | "deployedLinkReferences": {} 98 | } 99 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/UpgradeableBeacon.sol) 3 | 4 | pragma solidity ^0.8.20; 5 | 6 | import {IBeacon} from "./IBeacon.sol"; 7 | import {Ownable} from "../../access/Ownable.sol"; 8 | 9 | /** 10 | * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their 11 | * implementation contract, which is where they will delegate all function calls. 12 | * 13 | * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon. 14 | */ 15 | contract UpgradeableBeacon is IBeacon, Ownable { 16 | address private _implementation; 17 | 18 | /** 19 | * @dev The `implementation` of the beacon is invalid. 20 | */ 21 | error BeaconInvalidImplementation(address implementation); 22 | 23 | /** 24 | * @dev Emitted when the implementation returned by the beacon is changed. 25 | */ 26 | event Upgraded(address indexed implementation); 27 | 28 | /** 29 | * @dev Sets the address of the initial implementation, and the initial owner who can upgrade the beacon. 30 | */ 31 | constructor(address implementation_, address initialOwner) Ownable(initialOwner) { 32 | _setImplementation(implementation_); 33 | } 34 | 35 | /** 36 | * @dev Returns the current implementation address. 37 | */ 38 | function implementation() public view virtual returns (address) { 39 | return _implementation; 40 | } 41 | 42 | /** 43 | * @dev Upgrades the beacon to a new implementation. 44 | * 45 | * Emits an {Upgraded} event. 46 | * 47 | * Requirements: 48 | * 49 | * - msg.sender must be the owner of the contract. 50 | * - `newImplementation` must be a contract. 51 | */ 52 | function upgradeTo(address newImplementation) public virtual onlyOwner { 53 | _setImplementation(newImplementation); 54 | } 55 | 56 | /** 57 | * @dev Sets the implementation contract address for this beacon 58 | * 59 | * Requirements: 60 | * 61 | * - `newImplementation` must be a contract. 62 | */ 63 | function _setImplementation(address newImplementation) private { 64 | if (newImplementation.code.length == 0) { 65 | revert BeaconInvalidImplementation(newImplementation); 66 | } 67 | _implementation = newImplementation; 68 | emit Upgraded(newImplementation); 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /frontend-web3-daap/src/logo.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /backend-smartcontract/node_modules/@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v5.2.0) (proxy/beacon/BeaconProxy.sol) 3 | 4 | pragma solidity ^0.8.22; 5 | 6 | import {IBeacon} from "./IBeacon.sol"; 7 | import {Proxy} from "../Proxy.sol"; 8 | import {ERC1967Utils} from "../ERC1967/ERC1967Utils.sol"; 9 | 10 | /** 11 | * @dev This contract implements a proxy that gets the implementation address for each call from an {UpgradeableBeacon}. 12 | * 13 | * The beacon address can only be set once during construction, and cannot be changed afterwards. It is stored in an 14 | * immutable variable to avoid unnecessary storage reads, and also in the beacon storage slot specified by 15 | * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] so that it can be accessed externally. 16 | * 17 | * CAUTION: Since the beacon address can never be changed, you must ensure that you either control the beacon, or trust 18 | * the beacon to not upgrade the implementation maliciously. 19 | * 20 | * IMPORTANT: Do not use the implementation logic to modify the beacon storage slot. Doing so would leave the proxy in 21 | * an inconsistent state where the beacon storage slot does not match the beacon address. 22 | */ 23 | contract BeaconProxy is Proxy { 24 | // An immutable address for the beacon to avoid unnecessary SLOADs before each delegate call. 25 | address private immutable _beacon; 26 | 27 | /** 28 | * @dev Initializes the proxy with `beacon`. 29 | * 30 | * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This 31 | * will typically be an encoded function call, and allows initializing the storage of the proxy like a Solidity 32 | * constructor. 33 | * 34 | * Requirements: 35 | * 36 | * - `beacon` must be a contract with the interface {IBeacon}. 37 | * - If `data` is empty, `msg.value` must be zero. 38 | */ 39 | constructor(address beacon, bytes memory data) payable { 40 | ERC1967Utils.upgradeBeaconToAndCall(beacon, data); 41 | _beacon = beacon; 42 | } 43 | 44 | /** 45 | * @dev Returns the current implementation address of the associated beacon. 46 | */ 47 | function _implementation() internal view virtual override returns (address) { 48 | return IBeacon(_getBeacon()).implementation(); 49 | } 50 | 51 | /** 52 | * @dev Returns the beacon. 53 | */ 54 | function _getBeacon() internal view virtual returns (address) { 55 | return _beacon; 56 | } 57 | } 58 | --------------------------------------------------------------------------------