{"file_path":"apps/equity/contracts/factory/TokenFactory.sol","creation_status":"success","source_code":"/**\n * @title TokenFactory\n * @author Team 3301 \n * @dev Token factory to be used by operators to deploy arbitrary Sygnum Equity Token.\n */\n\npragma solidity 0.8.8;\n\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/Initializable.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/role/base/Operatorable.sol\";\n\nimport \"./ProxyDeployer.sol\";\nimport \"./TokenDeployer.sol\";\nimport \"./Details.sol\";\n\ncontract TokenFactory is Initializable, Operatorable {\n address public whitelist;\n address public proxyAdmin;\n address public implementation;\n address public traderOperators;\n address public blockerOperators;\n\n error TokenFactoryEmptyBaseOperatorsAddress();\n error TokenFactoryEmptyTraderOperatorsAddress();\n error TokenFactoryEmptyBlockerOperatorsAddress();\n error TokenFactoryEmptyWhitelistAddress();\n error TokenFactoryEmptyImplementationAddress();\n error TokenFactoryEmptyProxyAdminAddress();\n error TokenFactoryCallerNotProxyAdmin();\n\n event UpdatedWhitelist(address indexed whitelist);\n event UpdatedTraderOperators(address indexed traderOperators);\n event UpdatedBlockerOperators(address indexed blockerOperators);\n event UpdatedProxyAdmin(address indexed proxyAdmin);\n event UpdatedImplementation(address indexed implementation);\n event NewTokenDeployed(address indexed issuer, address token, address proxy);\n\n /**\n * @dev Initialization instead of constructor, called once. Sets BaseOperators contract through pausable contract\n * resulting in use of Operatorable contract within this contract.\n * @param _baseOperators BaseOperators contract address.\n * @param _traderOperators TraderOperators contract address.\n * @param _blockerOperators BlockerOperators contract address.\n * @param _whitelist Whitelist contract address.\n */\n function initialize(\n address _baseOperators,\n address _traderOperators,\n address _blockerOperators,\n address _whitelist,\n address _implementation,\n address _proxyAdmin\n ) public virtual initializer {\n if (_baseOperators == address(0)) revert TokenFactoryEmptyBaseOperatorsAddress();\n if (_traderOperators == address(0)) revert TokenFactoryEmptyTraderOperatorsAddress();\n if (_blockerOperators == address(0)) revert TokenFactoryEmptyBlockerOperatorsAddress();\n if (_whitelist == address(0)) revert TokenFactoryEmptyWhitelistAddress();\n if (_implementation == address(0)) revert TokenFactoryEmptyImplementationAddress();\n if (_proxyAdmin == address(0)) revert TokenFactoryEmptyProxyAdminAddress();\n\n traderOperators = _traderOperators;\n blockerOperators = _blockerOperators;\n whitelist = _whitelist;\n proxyAdmin = _proxyAdmin;\n implementation = _implementation;\n\n super.initialize(_baseOperators);\n }\n\n /**\n * @dev allows operator, system or relay to launch a new token with a new name, symbol, decimals, category, and issuer.\n * Defaults to using whitelist stored in this contract. If _whitelist is address(0), else it will use\n * _whitelist as the param to pass into the new token's constructor upon deployment\n * @param _details token details as defined by the TokenDetails struct\n * @param _whitelist address\n */\n function newToken(\n Details.TokenDetails memory _details,\n address _whitelist\n ) public virtual onlyOperatorOrSystemOrRelay returns (address, address) {\n address whitelistAddress;\n _whitelist == address(0) ? whitelistAddress = whitelist : whitelistAddress = _whitelist;\n address baseOperators = getOperatorsContract();\n\n address proxy = ProxyDeployer.deployTokenProxy(implementation, proxyAdmin, \"\");\n\n TokenDeployer.initializeToken(\n proxy,\n baseOperators,\n whitelistAddress,\n traderOperators,\n blockerOperators,\n _details\n );\n\n emit NewTokenDeployed(_details.issuer, implementation, proxy);\n return (implementation, proxy);\n }\n\n /**\n * @dev updates the whitelist to be used for future generated tokens\n * @param _whitelist address\n */\n function updateWhitelist(address _whitelist) public virtual onlyOperator {\n if (_whitelist == address(0)) revert TokenFactoryEmptyWhitelistAddress();\n whitelist = _whitelist;\n emit UpdatedWhitelist(whitelist);\n }\n\n /**\n * @dev updates the traderOperators contract address to be used for future generated tokens\n * @param _traderOperators address\n */\n function updateTraderOperators(address _traderOperators) public virtual onlyOperator {\n if (_traderOperators == address(0)) revert TokenFactoryEmptyTraderOperatorsAddress();\n traderOperators = _traderOperators;\n emit UpdatedTraderOperators(_traderOperators);\n }\n\n /**\n * @dev updates the blockerOperators contract address to be used for future generated tokens\n * @param _blockerOperators address\n */\n function updateBlockerOperators(address _blockerOperators) public virtual onlyOperator {\n if (_blockerOperators == address(0)) revert TokenFactoryEmptyBlockerOperatorsAddress();\n blockerOperators = _blockerOperators;\n emit UpdatedBlockerOperators(_blockerOperators);\n }\n\n /**\n * @dev update the implementation address used when deploying proxy contracts\n * @param _implementation address\n */\n function updateImplementation(address _implementation) public virtual onlyOperator {\n if (_implementation == address(0)) revert TokenFactoryEmptyImplementationAddress();\n implementation = _implementation;\n emit UpdatedImplementation(implementation);\n }\n\n /**\n * @dev update the proxy admin address used when deploying proxy contracts\n * @param _proxyAdmin address\n */\n function updateProxyAdmin(address _proxyAdmin) public virtual {\n if (_proxyAdmin == address(0)) revert TokenFactoryEmptyProxyAdminAddress();\n if (msg.sender != proxyAdmin) revert TokenFactoryCallerNotProxyAdmin();\n proxyAdmin = _proxyAdmin;\n emit UpdatedProxyAdmin(proxyAdmin);\n }\n}\n","deployed_bytecode":"0x608060405234801561001057600080fd5b50600436106101a35760003560e01c80635c60da1b116100ee578063a315059d11610097578063c4d66de811610071578063c4d66de81461034b578063cc2a9a5b1461035e578063d0ea5f4d14610371578063e649534c1461038457600080fd5b8063a315059d14610312578063acf39bdc14610325578063bb48cd3a1461033857600080fd5b80636d70f7ae116100c85780636d70f7ae146102e45780638535a56b146102f757806393e59dc1146102ff57600080fd5b80635c60da1b146102ad5780635ead86c6146102c0578063668f6ace146102d157600080fd5b806329518514116101505780633d0f963e1161012a5780633d0f963e146102745780633e47158c146102875780634dfed3421461029a57600080fd5b8063295185141461024357806334cdcf2614610256578063392e53cd1461026957600080fd5b80631c6bbabc116101815780631c6bbabc146101e357806324d7806c1461020d57806326cb32b71461023057600080fd5b8063025b22bc146101a85780630551a7e8146101bd5780631745145e146101d0575b600080fd5b6101bb6101b6366004610f3c565b6103b7565b005b6101bb6101cb366004610f3c565b61044e565b6101bb6101de366004610f3c565b6104e5565b6034546001600160a01b03165b6040516001600160a01b0390911681526020015b60405180910390f35b61022061021b366004610f3c565b61057e565b6040519015158152602001610204565b61022061023e366004610f3c565b610603565b610220610251366004610f3c565b610636565b610220610264366004610f3c565b6106ed565b60005460ff16610220565b6101bb610282366004610f3c565b610720565b6036546101f0906001600160a01b031681565b6038546101f0906001600160a01b031681565b6037546101f0906001600160a01b031681565b6033546001600160a01b03166101f0565b6102206102df366004610f3c565b6107b7565b6102206102f2366004610f3c565b6107ea565b6101bb61081d565b6035546101f0906001600160a01b031681565b6101bb610320366004610f3c565b61088e565b6039546101f0906001600160a01b031681565b6101bb610346366004610f3c565b610925565b6101bb610359366004610f3c565b6109c1565b6101bb61036c366004610f60565b610a62565b61022061037f366004610f3c565b610c48565b6103976103923660046110d8565b610c7b565b604080516001600160a01b03938416815292909116602083015201610204565b6103c0336107ea565b6103dd5760405163aa49d14f60e01b815260040160405180910390fd5b6001600160a01b0381166104045760405163b989191160e01b815260040160405180910390fd5b603780546001600160a01b0319166001600160a01b0383169081179091556040517f87c4e67a766ffddda27f441d63853a36ae64fbb07775a7c59d395e064b204eeb90600090a250565b610457336107ea565b6104745760405163aa49d14f60e01b815260040160405180910390fd5b6001600160a01b03811661049b5760405163150a272360e21b815260040160405180910390fd5b603880546001600160a01b0319166001600160a01b0383169081179091556040517f33b19b10bca1ab6e062300899cca340a11747d79bb1acef5c8f73fcdb866487c90600090a250565b6104ee3361057e565b61050b5760405163590f633960e01b815260040160405180910390fd5b6001600160a01b03811661053257604051638d9b385f60e01b815260040160405180910390fd5b603480546001600160a01b0319166001600160a01b03831690811790915560405133907f01e6311290e7fb795a47761d6ca6a39b9c898bbf2e8b0e40211aa9f2f6c0202990600090a350565b603354604051630935e01b60e21b81526001600160a01b03838116600483015260009216906324d7806c906024015b60206040518083038186803b1580156105c557600080fd5b505afa1580156105d9573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906105fd9190611208565b92915050565b6033546040516326cb32b760e01b81526001600160a01b03838116600483015260009216906326cb32b7906024016105ad565b6033546040516336b87bd760e11b81526001600160a01b0383811660048301526000921690636d70f7ae906024015b60206040518083038186803b15801561067d57600080fd5b505afa158015610691573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106b59190611208565b806105fd5750603354604051631a66e79360e11b81526001600160a01b038481166004830152909116906334cdcf26906024016105ad565b603354604051631a66e79360e11b81526001600160a01b03838116600483015260009216906334cdcf26906024016105ad565b610729336107ea565b6107465760405163aa49d14f60e01b815260040160405180910390fd5b6001600160a01b03811661076d576040516329ff050d60e21b815260040160405180910390fd5b603580546001600160a01b0319166001600160a01b0383169081179091556040517fd3fd2ed0d40b467e5340419d6b5308a20f2378b2e550443b19adde6da2383c0390600090a250565b603354604051633347b56760e11b81526001600160a01b038381166004830152600092169063668f6ace906024016105ad565b6033546040516336b87bd760e11b81526001600160a01b0383811660048301526000921690636d70f7ae906024016105ad565b6034546001600160a01b031661084657604051638d9b385f60e01b815260040160405180910390fd5b6034546001600160a01b03163314610877576040516385df92a760e01b815233600482015260240160405180910390fd5b60345461088c906001600160a01b0316610ea1565b565b610897336107ea565b6108b45760405163aa49d14f60e01b815260040160405180910390fd5b6001600160a01b0381166108db57604051637ee952c960e01b815260040160405180910390fd5b603980546001600160a01b0319166001600160a01b0383169081179091556040517f0860da9a51cc2ff39ef2fe8d67a40792b01a30b4fbc67ebaa56785777c214c2090600090a250565b6001600160a01b03811661094c5760405163a98afe6d60e01b815260040160405180910390fd5b6036546001600160a01b031633146109775760405163b4b8345360e01b815260040160405180910390fd5b603680546001600160a01b0319166001600160a01b0383169081179091556040517ffe6d16ecf6ab2a1bb269c55684f6a1b20c1f9a756787689f873061b4d999e76e90600090a250565b600054610100900460ff16158080156109da5750303b15155b80156109e8575060005460ff165b15610a0657604051635428559160e01b815260040160405180910390fd5b8015610a1c576000805461ffff19166101011790555b610a2582610ea1565b8015610a5e576000805461ff00191681556040517f5daa87a0e9463431830481fd4b6e3403442dfb9a12b9c07597e9f61d50b633c89190a15b5050565b600054610100900460ff1615808015610a7b5750303b15155b8015610a89575060005460ff165b15610aa757604051635428559160e01b815260040160405180910390fd5b8015610abd576000805461ffff19166101011790555b6001600160a01b038716610ae457604051632d9d123b60e21b815260040160405180910390fd5b6001600160a01b038616610b0b5760405163150a272360e21b815260040160405180910390fd5b6001600160a01b038516610b3257604051637ee952c960e01b815260040160405180910390fd5b6001600160a01b038416610b59576040516329ff050d60e21b815260040160405180910390fd5b6001600160a01b038316610b805760405163b989191160e01b815260040160405180910390fd5b6001600160a01b038216610ba75760405163a98afe6d60e01b815260040160405180910390fd5b603880546001600160a01b03199081166001600160a01b038981169190911790925560398054821688841617905560358054821687841617905560368054821685841617905560378054909116918516919091179055610c06876109c1565b8015610c3f576000805461ff00191681556040517f5daa87a0e9463431830481fd4b6e3403442dfb9a12b9c07597e9f61d50b633c89190a15b50505050505050565b603354604051630935e01b60e21b81526001600160a01b03838116600483015260009216906324d7806c90602401610665565b600080610c87336107ea565b158015610c9a5750610c98336106ed565b155b8015610cac5750610caa33610603565b155b15610cca576040516357815f6160e01b815260040160405180910390fd5b60006001600160a01b03841615610ce357508280610cf2565b506035546001600160a01b0316805b506000610d076033546001600160a01b031690565b60375460365460405163170b2d2760e21b81526001600160a01b039283166004820152911660248201526060604482015260006064820181905291925073aa248a970cad3e550438e3bffa9ca6bcf8b2b3ea90635c2cb49c9060840160206040518083038186803b158015610d7b57600080fd5b505af4158015610d8f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610db3919061122a565b603854603954604051631f8c201560e21b81529293507356061aed8e12e6520dc1eb605f914e5bba5e8f1792637e30805492610e0892869288928a926001600160a01b03918216929116908f90600401611294565b60006040518083038186803b158015610e2057600080fd5b505af4158015610e34573d6000803e3d6000fd5b5050505060a0870151603754604080516001600160a01b039283168152848316602082015291909216917f64b00226c8598e9a82d36c84eb8b9e0657ca37939d111756bd51164ca859f90d910160405180910390a26037546001600160a01b031697909650945050505050565b6001600160a01b038116610ec857604051638d9b385f60e01b815260040160405180910390fd5b603380546001600160a01b0319166001600160a01b03831690811790915560405133907f581e9e5016a25985d2da9da423c68d9946de634ff0e3447eaaa9575d135e819e90600090a350565b6001600160a01b0381168114610f2957600080fd5b50565b8035610f3781610f14565b919050565b600060208284031215610f4e57600080fd5b8135610f5981610f14565b9392505050565b60008060008060008060c08789031215610f7957600080fd5b8635610f8481610f14565b95506020870135610f9481610f14565b94506040870135610fa481610f14565b93506060870135610fb481610f14565b92506080870135610fc481610f14565b915060a0870135610fd481610f14565b809150509295509295509295565b634e487b7160e01b600052604160045260246000fd5b604051610100810167ffffffffffffffff8111828210171561101c5761101c610fe2565b60405290565b600082601f83011261103357600080fd5b813567ffffffffffffffff8082111561104e5761104e610fe2565b604051601f8301601f19908116603f0116810190828211818310171561107657611076610fe2565b8160405283815286602085880101111561108f57600080fd5b836020870160208301376000602085830101528094505050505092915050565b803560ff81168114610f3757600080fd5b80356001600160e01b031981168114610f3757600080fd5b600080604083850312156110eb57600080fd5b823567ffffffffffffffff8082111561110357600080fd5b90840190610100828703121561111857600080fd5b611120610ff8565b82358281111561112f57600080fd5b61113b88828601611022565b82525060208301358281111561115057600080fd5b61115c88828601611022565b60208301525061116e604084016110af565b604082015261117f606084016110c0565b606082015260808301358281111561119657600080fd5b6111a288828601611022565b6080830152506111b460a08401610f2c565b60a082015260c0830135828111156111cb57600080fd5b6111d788828601611022565b60c0830152506111e960e08401610f2c565b60e082015293506111ff91505060208401610f2c565b90509250929050565b60006020828403121561121a57600080fd5b81518015158114610f5957600080fd5b60006020828403121561123c57600080fd5b8151610f5981610f14565b6000815180845260005b8181101561126d57602081850181015186830182015201611251565b8181111561127f576000602083870101525b50601f01601f19169290920160200192915050565b60006001600160a01b03808916835280881660208401528087166040840152808616606084015280851660808401525060c060a083015282516101008060c08501526112e46101c0850183611247565b9150602085015160bf19808685030160e08701526113028483611247565b9350604087015191506113198387018360ff169052565b60608701516001600160e01b03191661012087015260808701518685038201610140880152925061134a8484611247565b935060a087015192506113696101608701846001600160a01b03169052565b60c08701519250808685030161018087015250506113878282611247565b91505060e08401516113a56101a08501826001600160a01b03169052565b509897505050505050505056fea26469706673582212205be4cefdef2ba0e505e85ec783fdea56955ec45eecb7a376c4e590de73e3b46364736f6c63430008080033","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"github_repository_metadata":null,"compiler_settings":{"evmVersion":"petersburg","libraries":{"apps/equity/contracts/factory/ProxyDeployer.sol":{"ProxyDeployer":"0xaa248a970cad3e550438e3bffa9ca6bcf8b2b3ea"},"apps/equity/contracts/factory/TokenDeployer.sol":{"TokenDeployer":"0x56061AED8e12e6520dC1eB605f914E5BbA5e8f17"}},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"enabled":true,"runs":300},"remappings":["@chainlink/contracts/=dependencies/@chainlink-contracts-1.3.0/","@gnosis.pm/safe-contracts/=dependencies/@gnosis-pm-safe-contracts-1.3.0/","@gnosis.pm/zodiac/=dependencies/gnosisguild-zodiac-4.0.5/","@openzeppelin-contracts/=dependencies/@openzeppelin-contracts-4.9.3/","@openzeppelin/contracts-upgradeable/=dependencies/@openzeppelin-contracts-upgradeable-4.9.3/","@openzeppelin/contracts-upgradeable/access/=dependencies/@openzeppelin-contracts-upgradeable-5.0.0/access/","@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-4.9.3/","@rari-capital/solmate/=dependencies/solmate-6.8.0/","@safe-global/safe-contracts/=dependencies/safe-global-safe-smart-account-1.4.1-3/","@sygnum/solidity-base-contracts/=apps/baseContracts/","forge-std/=dependencies/forge-std-1.9.4/src/","openzeppelin-contracts-upgradeable/=dependencies/@openzeppelin-contracts-upgradeable-4.9.3/","operator-filter-registry/=dependencies/projectopensea-operator-filter-registry-1.4.2/","@chainlink-contracts-1.3.0/=dependencies/@chainlink-contracts-1.3.0/src/","@gnosis-pm-safe-contracts-1.3.0/=dependencies/@gnosis-pm-safe-contracts-1.3.0/contracts/","@openzeppelin-contracts-4.9.3/=dependencies/@openzeppelin-contracts-4.9.3/","@openzeppelin-contracts-upgradeable-4.9.3/=dependencies/@openzeppelin-contracts-upgradeable-4.9.3/","@openzeppelin-contracts-upgradeable-5.0.0/=dependencies/@openzeppelin-contracts-upgradeable-5.0.0/","forge-std-1.9.4/=dependencies/forge-std-1.9.4/src/","gnosisguild-zodiac-4.0.5/=dependencies/gnosisguild-zodiac-4.0.5/contracts/","projectopensea-operator-filter-registry-1.4.2/=dependencies/projectopensea-operator-filter-registry-1.4.2/src/","safe-global-safe-smart-account-1.4.1-3/=dependencies/safe-global-safe-smart-account-1.4.1-3/","solmate-6.8.0/=dependencies/solmate-6.8.0/src/"],"viaIR":false},"optimization_runs":300,"sourcify_repo_url":null,"decoded_constructor_args":null,"compiler_version":"0.8.8+commit.dddeac2f","is_verified_via_verifier_alliance":true,"verified_at":"2026-09-13T13:38:15.881608Z","implementations":[{"address_hash":"0x7616b08676117e1aAb542E53fE3f7B12f7596d37","name":"SygnumTokenLatest"}],"proxy_type":"basic_implementation","external_libraries":[{"name":"apps/equity/contracts/factory/ProxyDeployer.sol:ProxyDeployer","address_hash":"0xAa248a970CAD3e550438E3bfFa9ca6BcF8b2B3ea"},{"name":"apps/equity/contracts/factory/TokenDeployer.sol:TokenDeployer","address_hash":"0x56061AED8e12e6520dC1eB605f914E5BbA5e8f17"}],"creation_bytecode":"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","name":"TokenFactory","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"petersburg","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"apps/baseContracts/contracts/helpers/Freezable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title Freezable\n * @author Team 3301 \n * @dev Freezable contract to freeze functionality for particular addresses. Freezing/unfreezing is controlled\n * by operators in Operatorable contract which is initialized with the relevant BaseOperators address.\n */\n\npragma solidity ^0.8.0;\n\nimport \"../role/base/Operatorable.sol\";\n\ncontract Freezable is Operatorable {\n mapping(address => bool) public frozen;\n\n /**\n * @dev Error: \"Freezable: Empty address\"\n */\n error FreezableZeroAddress();\n\n /**\n * @dev Error: \"Freezable: account is frozen\"\n */\n error FreezableAccountFrozen();\n\n /**\n * @dev Error: \"Freezable: account is not frozen\"\n */\n error FreezableAccountNotFrozen();\n\n /**\n * @dev Error: \"Freezable: batch count is greater than 256\"\n */\n error FreezableBatchCountTooLarge(uint256 _batchCount);\n\n event FreezeToggled(address indexed account, bool frozen);\n\n /**\n * @dev Reverts if address is empty.\n * @param _address address to validate.\n */\n modifier onlyValidAddress(address _address) {\n if (_address == address(0)) revert FreezableZeroAddress();\n _;\n }\n\n /**\n * @dev Reverts if account address is frozen.\n * @param _account address to validate is not frozen.\n */\n modifier whenNotFrozen(address _account) {\n if (frozen[_account]) revert FreezableAccountFrozen();\n _;\n }\n\n /**\n * @dev Reverts if account address is not frozen.\n * @param _account address to validate is frozen.\n */\n modifier whenFrozen(address _account) {\n if (!frozen[_account]) revert FreezableAccountNotFrozen();\n _;\n }\n\n /**\n * @dev Getter to determine if address is frozen.\n * @param _account address to determine if frozen or not.\n * @return bool is frozen\n */\n function isFrozen(address _account) public view virtual returns (bool) {\n return frozen[_account];\n }\n\n /**\n * @dev Toggle freeze/unfreeze on _account address, with _toggled being true/false.\n * @param _account address to toggle.\n * @param _toggled freeze/unfreeze.\n */\n function toggleFreeze(address _account, bool _toggled) public virtual onlyValidAddress(_account) onlyOperator {\n frozen[_account] = _toggled;\n emit FreezeToggled(_account, _toggled);\n }\n\n /**\n * @dev Batch freeze/unfreeze multiple addresses, with _toggled being true/false.\n * @param _addresses address array.\n * @param _toggled freeze/unfreeze.\n */\n function batchToggleFreeze(address[] memory _addresses, bool _toggled) public virtual {\n if (_addresses.length > 256) revert FreezableBatchCountTooLarge(_addresses.length);\n\n for (uint256 i = 0; i < _addresses.length; ++i) {\n toggleFreeze(_addresses[i], _toggled);\n }\n }\n}\n"},{"file_path":"apps/equity/contracts/token/ERC20/ERC20SygnumDetailed.sol","source_code":"/**\n * @title ERC20SygnumDetailed\n * @author Team 3301 \n * @dev ERC20 Standard Token with additional details and role set.\n */\n\npragma solidity 0.8.8;\n\nimport \"./ERC20Detailed.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/role/base/Operatorable.sol\";\n\ncontract ERC20SygnumDetailed is ERC20Detailed, Operatorable {\n bytes4 private _category;\n string private _class;\n address private _issuer;\n\n event NameUpdated(address issuer, string name, address token);\n event SymbolUpdated(address issuer, string symbol, address token);\n event CategoryUpdated(address issuer, bytes4 category, address token);\n event ClassUpdated(address issuer, string class, address token);\n event IssuerUpdated(address issuer, address newIssuer, address token);\n\n /**\n * @dev Sets the values for `name`, `symbol`, `decimals`, `category`, `class` and `issuer`. All are\n * mutable apart from `issuer`, which is immutable.\n * @param name string\n * @param symbol string\n * @param decimals uint8\n * @param category bytes4\n * @param class string\n * @param issuer address\n */\n function _setDetails(\n string memory name,\n string memory symbol,\n uint8 decimals,\n bytes4 category,\n string memory class,\n address issuer\n ) internal virtual {\n _name = name;\n _symbol = symbol;\n _decimals = decimals;\n _category = category;\n _class = class;\n _issuer = issuer;\n }\n\n /**\n * @dev Returns the category of the token.\n */\n function category() public view virtual returns (bytes4) {\n return _category;\n }\n\n /**\n * @dev Returns the class of the token.\n */\n function class() public view virtual returns (string memory) {\n return _class;\n }\n\n /**\n * @dev Returns the issuer of the token.\n */\n function issuer() public view virtual returns (address) {\n return _issuer;\n }\n\n /**\n * @dev Updates the name of the token, only callable by Sygnum operator.\n * @param name_ The new name.\n */\n function updateName(string memory name_) public virtual onlyOperator {\n _name = name_;\n emit NameUpdated(msg.sender, _name, address(this));\n }\n\n /**\n * @dev Updates the symbol of the token, only callable by Sygnum operator.\n * @param symbol_ The new symbol.\n */\n function updateSymbol(string memory symbol_) public virtual onlyOperator {\n _symbol = symbol_;\n emit SymbolUpdated(msg.sender, symbol_, address(this));\n }\n\n /**\n * @dev Updates the category of the token, only callable by Sygnum operator.\n * @param category_ The new cateogry.\n */\n function updateCategory(bytes4 category_) public virtual onlyOperator {\n _category = category_;\n emit CategoryUpdated(msg.sender, _category, address(this));\n }\n\n /**\n * @dev Updates the class of the token, only callable by Sygnum operator.\n * @param class_ The new class.\n */\n function updateClass(string memory class_) public virtual onlyOperator {\n _class = class_;\n emit ClassUpdated(msg.sender, _class, address(this));\n }\n\n /**\n * @dev Updates issuer ownership, only callable by Sygnum operator.\n * @param issuer_ The new issuer.\n */\n function updateIssuer(address issuer_) public virtual onlyOperator {\n _issuer = issuer_;\n emit IssuerUpdated(msg.sender, _issuer, address(this));\n }\n}\n"},{"file_path":"dependencies/@chainlink-contracts-1.3.0/src/v0.8/shared/interfaces/AggregatorV2V3Interface.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {AggregatorInterface} from \"./AggregatorInterface.sol\";\nimport {AggregatorV3Interface} from \"./AggregatorV3Interface.sol\";\n\n// solhint-disable-next-line interface-starts-with-i\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface {}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Overload/ERC20.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/utils/Context.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20Mintable}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20 {\n using SafeMath for uint256;\n\n mapping(address => uint256) internal _balances;\n\n mapping(address => mapping(address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20};\n *\n * Requirements:\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for `sender`'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n _approve(\n sender,\n _msgSender(),\n _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\")\n );\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n _approve(\n _msgSender(),\n spender,\n _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\")\n );\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _balances[sender] = _balances[sender].sub(amount, \"ERC20: transfer amount exceeds balance\");\n _balances[recipient] = _balances[recipient].add(amount);\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _totalSupply = _totalSupply.add(amount);\n _balances[account] = _balances[account].add(amount);\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _balances[account] = _balances[account].sub(amount, \"ERC20: burn amount exceeds balance\");\n _totalSupply = _totalSupply.sub(amount);\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.\n *\n * This is internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`.`amount` is then deducted\n * from the caller's allowance.\n *\n * See {_burn} and {_approve}.\n */\n function _burnFrom(address account, uint256 amount) internal virtual {\n _burn(account, amount);\n _approve(\n account,\n _msgSender(),\n _allowances[account][_msgSender()].sub(amount, \"ERC20: burn amount exceeds allowance\")\n );\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/interfaces/draft-IERC1822.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n /**\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n * address.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy.\n */\n function proxiableUUID() external view returns (bytes32);\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/instance/Whitelistable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title Whitelistable\n * @author Team 3301 \n * @dev Whitelistable contract stores the Whitelist contract address, and modifiers for\n * contracts.\n */\n\npragma solidity ^0.8.0;\n\nimport \"../../role/base/Operatorable.sol\";\nimport \"../interface/IWhitelist.sol\";\nimport \"../Initializable.sol\";\n\ncontract Whitelistable is Initializable, Operatorable {\n IWhitelist internal whitelistInst;\n address private whitelistPending;\n\n /**\n * @dev Error: \"Whitelistable: account is not whitelisted\"\n */\n error WhitelistableAccountNotWhitelisted();\n\n /**\n * @dev Error: \"Whitelistable: address of new whitelist contract can not be zero\"\n */\n error WhitelistableWhitelistContractZeroAddress();\n\n /**\n * @dev Error: \"Whitelistable: should be called from new whitelist contract\"\n */\n error WhitelistableCallerNotWhitelistContract(address _caller);\n\n event WhitelistContractChanged(address indexed caller, address indexed whitelistAddress);\n event WhitelistContractPending(address indexed caller, address indexed whitelistAddress);\n\n /**\n * @dev Reverts if _account is not whitelisted.\n * @param _account address to determine if whitelisted.\n */\n modifier whenWhitelisted(address _account) {\n if (!isWhitelisted(_account)) revert WhitelistableAccountNotWhitelisted();\n _;\n }\n\n /**\n * @dev Initialization instead of constructor, called once. The setWhitelistContract function can be called only by Admin role with\n * confirmation through the whitelist contract.\n * @param _whitelist Whitelist contract address.\n * @param _baseOperators BaseOperators contract address.\n */\n function initialize(address _baseOperators, address _whitelist) public virtual initializer {\n _setOperatorsContract(_baseOperators);\n _setWhitelistContract(_whitelist);\n }\n\n /**\n * @dev Set the new the address of Whitelist contract, should be confirmed from whitelist contract by calling confirmFor(addr)\n * where addr is the address of current contract instance. This is done to prevent the case when the new contract address is\n * broken and control of the contract can be lost in such case\n * @param _whitelist Whitelist contract address.\n */\n function setWhitelistContract(address _whitelist) public onlyAdmin {\n if (_whitelist == address(0)) revert WhitelistableWhitelistContractZeroAddress();\n\n whitelistPending = _whitelist;\n emit WhitelistContractPending(msg.sender, _whitelist);\n }\n\n /**\n * @dev The function should be called from new whitelist contract by admin to insure that whitelistPending address\n * is the real contract address.\n */\n function confirmWhitelistContract() public {\n if (whitelistPending == address(0)) revert WhitelistableWhitelistContractZeroAddress();\n\n if (msg.sender != whitelistPending) revert WhitelistableCallerNotWhitelistContract(msg.sender);\n\n _setWhitelistContract(whitelistPending);\n }\n\n /**\n * @return The address of the Whitelist contract.\n */\n function getWhitelistContract() public view returns (address) {\n return address(whitelistInst);\n }\n\n /**\n * @return The pending address of the Whitelist contract.\n */\n function getWhitelistPending() public view returns (address) {\n return whitelistPending;\n }\n\n /**\n * @return If '_account' is whitelisted.\n */\n function isWhitelisted(address _account) public view returns (bool) {\n return whitelistInst.isWhitelisted(_account);\n }\n\n /** INTERNAL FUNCTIONS */\n function _setWhitelistContract(address _whitelist) internal {\n if (_whitelist == address(0)) revert WhitelistableWhitelistContractZeroAddress();\n\n whitelistInst = IWhitelist(_whitelist);\n emit WhitelistContractChanged(msg.sender, _whitelist);\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/role/interface/IBlockerOperators.sol","source_code":"// SPDX-License-Identifier: Unlicensed\n\n/**\n * @title IBlockerOperators\n * @notice Interface for BlockerOperators contract\n */\n\npragma solidity ^0.8.0;\n\nabstract contract IBlockerOperators {\n function isBlocker(address _account) external view virtual returns (bool);\n\n function addBlocker(address _account) external virtual;\n\n function removeBlocker(address _account) external virtual;\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/interface/IWhitelist.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\npragma solidity ^0.8.0;\n\n/**\n * @title IWhitelist\n * @notice Interface for Whitelist contract\n */\nabstract contract IWhitelist {\n function isWhitelisted(address _account) external view virtual returns (bool);\n\n function toggleWhitelist(address _account, bool _toggled) external virtual;\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/CLPriceFeedConnector.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title CLPriceFeedConnector\n * @author Team 3301 \n * @dev\n */\n\npragma solidity ^0.8.8;\n\nimport \"./interface/ICLPriceFeedConnector.sol\";\n\nimport {AggregatorV2V3Interface} from \"@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV2V3Interface.sol\";\n\ncontract CLPriceFeedConnector is ICLPriceFeedConnector {\n AggregatorV2V3Interface internal priceFeed;\n /**\n * @dev Event: \"Upon changing the address of CLPriceFeedConnector\"\n */\n event OracleContractChanged(address indexed newOracle);\n\n /**\n * @dev Returns the asset price in the base currency as per the description\n * @return (int256) latest price of the asset from the price feed\n */\n function getAssetPrice() external view virtual override returns (int256) {\n if (address(priceFeed) == address(0)) return 0;\n (, int256 assetPrice, , , ) = AggregatorV2V3Interface(priceFeed).latestRoundData();\n return assetPrice;\n }\n\n /**\n * @dev Returns the decimals of data feed or price feed oracle. asset and in which the base currency the asset price is calculated.\n * @return (uint8) decimals of price/data feed of the asset\n */\n function getPriceFeedDecimals() external view returns (uint8) {\n if (address(priceFeed) == address(0)) return 0;\n return AggregatorV2V3Interface(priceFeed).decimals();\n }\n\n /**\n * @dev Returns the description of data feed or price feed oracle. Mostly the description of which asset and in which the base currency the asset price is calculated.\n * @return (string) description of price/data feed of the asset\n */\n function getPriceFeedDescription() external view returns (string memory) {\n if (address(priceFeed) == address(0)) return \"\";\n return AggregatorV2V3Interface(priceFeed).description();\n }\n\n /**\n * @dev Returns the address or the proxy address of the price feed or data feed oracle configured\n * @return (address) address of the oracle\n */\n function getPriceFeedOracle() external view returns (address) {\n return address(priceFeed);\n }\n\n /** INTERNAL FUNCTIONS */\n function _setPriceFeedOracle(address _newPriceFeedOracle) internal {\n priceFeed = AggregatorV2V3Interface(_newPriceFeedOracle);\n emit OracleContractChanged(_newPriceFeedOracle);\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/token/ERC20/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n"},{"file_path":"apps/baseContracts/contracts/role/trader/TraderOperatorable.sol","source_code":"// SPDX-License-Identifier: Unlicensed\n\n/**\n * @title TraderOperatorable\n * @author Team 3301 \n * @dev TraderOperatorable contract stores TraderOperators contract address, and modifiers for\n * contracts.\n */\n\npragma solidity ^0.8.0;\n\nimport \"../interface/ITraderOperators.sol\";\nimport \"../base/Operatorable.sol\";\nimport \"../../helpers/Initializable.sol\";\n\ncontract TraderOperatorable is Operatorable {\n ITraderOperators internal traderOperatorsInst;\n address private traderOperatorsPending;\n\n /**\n * @dev Error: \"TraderOperatorable: caller is not trader\"\n */\n error TraderOperatorableCallerNotTrader();\n\n /**\n * @dev Error: \"TraderOperatorable: caller is not trader or operator or system\"\n */\n error TraderOperatorableCallerNotTraderOrOperatorOrSystem();\n\n /**\n * @dev Error: \"TraderOperatorable: address of new traderOperators contract can not be zero\"\n */\n error TraderOperatorableNewTraderOperatorsAddressZero();\n\n /**\n * @dev Error: \"TraderOperatorable: address of pending traderOperators contract can not be zero\"\n */\n error TraderOperatorablePendingTraderOperatorsAddressZero();\n\n /**\n * @dev Error: \"TraderOperatorable: should be called from new traderOperators contract\"\n */\n error TraderOperatorableCallerNotNewTraderOperator();\n\n event TraderOperatorsContractChanged(address indexed caller, address indexed traderOperatorsAddress);\n event TraderOperatorsContractPending(address indexed caller, address indexed traderOperatorsAddress);\n\n /**\n * @dev Reverts if sender does not have the trader role associated.\n */\n modifier onlyTrader() {\n if (!isTrader(msg.sender)) revert TraderOperatorableCallerNotTrader();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have the operator or trader role associated.\n */\n modifier onlyOperatorOrTraderOrSystem() {\n if (!isOperator(msg.sender) && !isTrader(msg.sender) && !isSystem(msg.sender))\n revert TraderOperatorableCallerNotTraderOrOperatorOrSystem();\n _;\n }\n\n /**\n * @dev Initialization instead of constructor, called once. The setTradersOperatorsContract function can be called only by Admin role with\n * confirmation through the operators contract.\n * @param _baseOperators BaseOperators contract address.\n * @param _traderOperators TraderOperators contract address.\n */\n function initialize(address _baseOperators, address _traderOperators) public virtual initializer {\n super.initialize(_baseOperators);\n _setTraderOperatorsContract(_traderOperators);\n }\n\n /**\n * @dev Set the new the address of Operators contract, should be confirmed from operators contract by calling confirmFor(addr)\n * where addr is the address of current contract instance. This is done to prevent the case when the new contract address is\n * broken and control of the contract can be lost in such case\n * @param _traderOperators TradeOperators contract address.\n */\n function setTraderOperatorsContract(address _traderOperators) public onlyAdmin {\n if (_traderOperators == address(0)) revert TraderOperatorableNewTraderOperatorsAddressZero();\n\n traderOperatorsPending = _traderOperators;\n emit TraderOperatorsContractPending(msg.sender, _traderOperators);\n }\n\n /**\n * @dev The function should be called from new operators contract by admin to insure that traderOperatorsPending address\n * is the real contract address.\n */\n function confirmTraderOperatorsContract() public {\n if (traderOperatorsPending == address(0)) revert TraderOperatorablePendingTraderOperatorsAddressZero();\n if (msg.sender != traderOperatorsPending) revert TraderOperatorableCallerNotNewTraderOperator();\n\n _setTraderOperatorsContract(traderOperatorsPending);\n }\n\n /**\n * @return The address of the TraderOperators contract.\n */\n function getTraderOperatorsContract() public view returns (address) {\n return address(traderOperatorsInst);\n }\n\n /**\n * @return The pending TraderOperators contract address\n */\n function getTraderOperatorsPending() public view returns (address) {\n return traderOperatorsPending;\n }\n\n /**\n * @return If '_account' has trader privileges.\n */\n function isTrader(address _account) public view returns (bool) {\n return traderOperatorsInst.isTrader(_account);\n }\n\n /** INTERNAL FUNCTIONS */\n function _setTraderOperatorsContract(address _traderOperators) internal {\n if (_traderOperators == address(0)) revert TraderOperatorableNewTraderOperatorsAddressZero();\n\n traderOperatorsInst = ITraderOperators(_traderOperators);\n emit TraderOperatorsContractChanged(msg.sender, _traderOperators);\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/proxy/ERC1967/ERC1967Upgrade.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../interfaces/IERC1967.sol\";\nimport \"../../interfaces/draft-IERC1822.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n */\nabstract contract ERC1967Upgrade is IERC1967 {\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {\n _upgradeTo(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {\n // Upgrades from old implementations will perform a rollback test. This test requires the new\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\n // this special case will break upgrade paths from old UUPS implementation to new ones.\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(newImplementation);\n } else {\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n require(slot == _IMPLEMENTATION_SLOT, \"ERC1967Upgrade: unsupported proxiableUUID\");\n } catch {\n revert(\"ERC1967Upgrade: new implementation is not UUPS\");\n }\n _upgradeToAndCall(newImplementation, data, forceCall);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(Address.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n require(\n Address.isContract(IBeacon(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n }\n }\n}\n"},{"file_path":"apps/equity/contracts/token/upgrade/prd/SygnumTokenV4.sol","source_code":"/**\n * @title MetadataUpgrade\n * @author Team 3301 \n * @dev Upgraded SygnumToken. This upgrade allows operator accounts to mint and burn tokens while paused.\n */\npragma solidity 0.8.8;\n\nimport \"./SygnumTokenV3.sol\";\n\ncontract SygnumTokenV4 is SygnumTokenV3 {\n bool public initializedV4;\n\n error SygnumTokenV4AlreadyInitialized();\n error SygnumTokenV4ZeroBurnAmount();\n\n // changed back to public for tests\n function initializeContractsAndConstructor(\n string memory _name,\n string memory _symbol,\n uint8 _decimals,\n bytes4 _category,\n string memory _class,\n address _issuer,\n address _baseOperators,\n address _whitelist,\n address _traderOperators,\n address _blockerOperators,\n string memory _tokenURI\n ) public virtual override {\n SygnumTokenV3.initializeContractsAndConstructor(\n _name,\n _symbol,\n _decimals,\n _category,\n _class,\n _issuer,\n _baseOperators,\n _whitelist,\n _traderOperators,\n _blockerOperators,\n _tokenURI\n );\n initializeV4();\n }\n\n function initializeV4() public virtual {\n if (initializedV4) revert SygnumTokenV4AlreadyInitialized();\n initializedV4 = true;\n }\n\n /**\n * @dev Modified _burn function allowing operators to burn while contract is paused/frozen\n * @param account address that funds will be minted to.\n * @param amount amount of funds that will be minted.\n */\n function _burn(address account, uint256 amount) internal virtual override {\n // Cannot use super. here as there is no way to selectively disable whenNotPaused,\n // we need to redefine the modifiers explicitly\n if (isOperator(msg.sender) && isWhitelisted(account)) {\n if (amount <= 0) revert SygnumTokenV4ZeroBurnAmount();\n ERC20Snapshot._burn(account, amount);\n } else {\n super._burn(account, amount);\n }\n }\n\n /**\n * @dev Modified _burnFor function allowing operators to burn while contract is paused/frozen\n * @param account address that funds will be minted to.\n * @param amount amount of funds that will be minted.\n */\n function _burnFor(address account, uint256 amount) internal virtual override {\n // Cannot use super. here as there is no way to selectively disable whenNotPaused,\n // we need to redefine the modifiers explicitly\n if (isOperator(msg.sender) && isWhitelisted(account)) {\n if (amount <= 0) revert SygnumTokenV4ZeroBurnAmount();\n ERC20Snapshot._burn(account, amount);\n } else {\n super._burnFor(account, amount);\n }\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Whitelist.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Whitelist\n * @author Team 3301 \n * @dev Overloading ERC20 functions to ensure that addresses attempting to particular\n * actions are whitelisted.\n */\n\npragma solidity ^0.8.0;\n\nimport \"./ERC20Overload/ERC20.sol\";\nimport \"../instance/Whitelistable.sol\";\n\ncontract ERC20Whitelist is ERC20, Whitelistable {\n /**\n * @dev Overload transfer function to validate sender and receiver are whitelisted.\n * @param to address that recieves the funds.\n * @param value amount of funds.\n */\n function transfer(\n address to,\n uint256 value\n ) public virtual override whenWhitelisted(msg.sender) whenWhitelisted(to) returns (bool) {\n return super.transfer(to, value);\n }\n\n /**\n * @dev Overload approve function to validate sender and spender are whitelisted.\n * @param spender address that can spend the funds.\n * @param value amount of funds.\n */\n function approve(\n address spender,\n uint256 value\n ) public virtual override whenWhitelisted(msg.sender) whenWhitelisted(spender) returns (bool) {\n return super.approve(spender, value);\n }\n\n /**\n * @dev Overload transferFrom function to validate sender, from and receiver are whitelisted.\n * @param from address that funds will be transferred from.\n * @param to address that funds will be transferred to.\n * @param value amount of funds.\n */\n function transferFrom(\n address from,\n address to,\n uint256 value\n ) public virtual override whenWhitelisted(msg.sender) whenWhitelisted(from) whenWhitelisted(to) returns (bool) {\n return super.transferFrom(from, to, value);\n }\n\n /**\n * @dev Overload increaseAllowance validate sender and spender are whitelisted.\n * @param spender address that will be allowed to transfer funds.\n * @param addedValue amount of funds to added to current allowance.\n */\n function increaseAllowance(\n address spender,\n uint256 addedValue\n ) public virtual override whenWhitelisted(spender) whenWhitelisted(msg.sender) returns (bool) {\n return super.increaseAllowance(spender, addedValue);\n }\n\n /**\n * @dev Overload decreaseAllowance validate sender and spender are whitelisted.\n * @param spender address that will be allowed to transfer funds.\n * @param subtractedValue amount of funds to be deducted to current allowance.\n */\n function decreaseAllowance(\n address spender,\n uint256 subtractedValue\n ) public virtual override whenWhitelisted(spender) whenWhitelisted(msg.sender) returns (bool) {\n return super.decreaseAllowance(spender, subtractedValue);\n }\n\n /**\n * @dev Overload _burn function to ensure that account has been whitelisted.\n * @param account address that funds will be burned from.\n * @param value amount of funds that will be burned.\n */\n function _burn(address account, uint256 value) internal virtual override whenWhitelisted(account) {\n super._burn(account, value);\n }\n\n /**\n * @dev Overload _burnFrom function to ensure sender and account have been whitelisted.\n * @param account address that funds will be burned from allowance.\n * @param amount amount of funds that will be burned.\n */\n function _burnFrom(\n address account,\n uint256 amount\n ) internal virtual override whenWhitelisted(msg.sender) whenWhitelisted(account) {\n super._burnFrom(account, amount);\n }\n\n /**\n * @dev Overload _mint function to ensure account has been whitelisted.\n * @param account address that funds will be minted to.\n * @param amount amount of funds that will be minted.\n */\n function _mint(address account, uint256 amount) internal virtual override whenWhitelisted(account) {\n super._mint(account, amount);\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Pausable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Pausable\n * @author Team 3301 \n * @dev Overloading ERC20 functions to ensure that the contract has not been paused.\n */\n\npragma solidity ^0.8.0;\n\nimport \"./ERC20Overload/ERC20.sol\";\nimport \"../Pausable.sol\";\n\ncontract ERC20Pausable is ERC20, Pausable {\n /**\n * @dev Overload transfer function to ensure contract has not been paused.\n * @param to address that recieves the funds.\n * @param value amount of funds.\n */\n function transfer(address to, uint256 value) public virtual override whenNotPaused returns (bool) {\n return super.transfer(to, value);\n }\n\n /**\n * @dev Overload approve function to ensure contract has not been paused.\n * @param spender address that can spend the funds.\n * @param value amount of funds.\n */\n function approve(address spender, uint256 value) public virtual override whenNotPaused returns (bool) {\n return super.approve(spender, value);\n }\n\n /**\n * @dev Overload transferFrom function to ensure contract has not been paused.\n * @param from address that funds will be transferred from.\n * @param to address that funds will be transferred to.\n * @param value amount of funds.\n */\n function transferFrom(\n address from,\n address to,\n uint256 value\n ) public virtual override whenNotPaused returns (bool) {\n return super.transferFrom(from, to, value);\n }\n\n /**\n * @dev Overload increaseAllowance function to ensure contract has not been paused.\n * @param spender address that will be allowed to transfer funds.\n * @param addedValue amount of funds to added to current allowance.\n */\n function increaseAllowance(\n address spender,\n uint256 addedValue\n ) public virtual override whenNotPaused returns (bool) {\n return super.increaseAllowance(spender, addedValue);\n }\n\n /**\n * @dev Overload decreaseAllowance function to ensure contract has not been paused.\n * @param spender address that will be allowed to transfer funds.\n * @param subtractedValue amount of funds to be deducted to current allowance.\n */\n function decreaseAllowance(\n address spender,\n uint256 subtractedValue\n ) public virtual override whenNotPaused returns (bool) {\n return super.decreaseAllowance(spender, subtractedValue);\n }\n\n /**\n * @dev Overload _burn function to ensure contract has not been paused.\n * @param account address that funds will be burned from.\n * @param value amount of funds that will be burned.\n */\n function _burn(address account, uint256 value) internal virtual override whenNotPaused {\n super._burn(account, value);\n }\n\n /**\n * @dev Overload _burnFrom function to ensure contract has not been paused.\n * @param account address that funds will be burned from allowance.\n * @param amount amount of funds that will be burned.\n */\n function _burnFrom(address account, uint256 amount) internal virtual override whenNotPaused {\n super._burnFrom(account, amount);\n }\n\n /**\n * @dev Overload _mint function to ensure contract has not been paused.\n * @param account address that funds will be minted to.\n * @param amount amount of funds that will be minted.\n */\n function _mint(address account, uint256 amount) internal virtual override whenNotPaused {\n super._mint(account, amount);\n }\n}\n"},{"file_path":"apps/equity/contracts/token/upgrade/prd/SygnumTokenV3.sol","source_code":"/**\n * @title MetadataUpgrade\n * @author Team 3301 \n * @dev Upgraded SygnumToken. This upgrade allows system accounts to confiscate tokens.\n */\npragma solidity 0.8.8;\n\nimport \"./SygnumTokenV2.sol\";\n\ncontract SygnumTokenV3 is SygnumTokenV2 {\n bool public initializedV3;\n\n error SygnumTokenV3AlreadyInitialized();\n\n // changed back to public for tests\n function initializeContractsAndConstructor(\n string memory _name,\n string memory _symbol,\n uint8 _decimals,\n bytes4 _category,\n string memory _class,\n address _issuer,\n address _baseOperators,\n address _whitelist,\n address _traderOperators,\n address _blockerOperators,\n string memory _tokenURI\n ) public virtual override {\n SygnumTokenV2.initializeContractsAndConstructor(\n _name,\n _symbol,\n _decimals,\n _category,\n _class,\n _issuer,\n _baseOperators,\n _whitelist,\n _traderOperators,\n _blockerOperators,\n _tokenURI\n );\n initializeV3();\n }\n\n function initializeV3() public virtual {\n if (initializedV3) revert SygnumTokenV3AlreadyInitialized();\n initializedV3 = true;\n }\n\n /**\n * @dev Modified _mint function allowing operators to mint while contract is paused\n * @param account address that funds will be minted to.\n * @param amount amount of funds that will be minted.\n */\n function _mint(address account, uint256 amount) internal virtual override {\n // Cannot use super. here as there is no way to selectively disable whenNotPaused,\n // we need to redefine the modifiers explicitly\n if (isOperator(msg.sender) && isWhitelisted(account)) {\n if (amount <= 0) revert ERC20MintableZeroMintAmount();\n ERC20Snapshot._mint(account, amount);\n } else {\n super._mint(account, amount);\n }\n }\n}\n"},{"file_path":"apps/equity/contracts/token/upgrade/prd/SygnumTokenV1.sol","source_code":"/**\n * @title MetadataUpgrade\n * @author Team 3301 \n * @dev Upgraded SygnumToken. This upgrade adds the \"tokenURI\" field, which can hold a link to off chain token metadata.\n */\npragma solidity 0.8.8;\n\nimport \"../../SygnumToken.sol\";\n\ncontract SygnumTokenV1 is SygnumToken {\n string public tokenURI;\n bool public initializedV1;\n\n error SygnumTokenV1AlreadyInitialized();\n\n event TokenUriUpdated(string newToken);\n\n // changed back to public for tests\n function initializeContractsAndConstructor(\n string memory _name,\n string memory _symbol,\n uint8 _decimals,\n bytes4 _category,\n string memory _class,\n address _issuer,\n address _baseOperators,\n address _whitelist,\n address _traderOperators,\n address _blockerOperators,\n string memory _tokenURI\n ) public virtual {\n SygnumToken.initializeContractsAndConstructor(\n _name,\n _symbol,\n _decimals,\n _category,\n _class,\n _issuer,\n _baseOperators,\n _whitelist,\n _traderOperators,\n _blockerOperators\n );\n initializeV1(_tokenURI);\n }\n\n function initializeV1(string memory _tokenURI) public virtual {\n if (initializedV1) revert SygnumTokenV1AlreadyInitialized();\n\n tokenURI = _tokenURI;\n initializedV1 = true;\n }\n\n function updateTokenURI(string memory _newToken) public virtual onlyOperator {\n tokenURI = _newToken;\n emit TokenUriUpdated(_newToken);\n }\n}\n"},{"file_path":"apps/equity/contracts/factory/ProxyDeployer.sol","source_code":"/**\n * @title ProxyDeployer\n * @author Team 3301 \n * @dev Library to deploy a proxy instance for a Sygnum.\n */\n\npragma solidity 0.8.8;\n\nimport \"../token/SygnumTokenProxy.sol\";\n\nlibrary ProxyDeployer {\n /**\n * @dev Deploy the proxy instance and initialize it\n * @param _tokenImplementation Address of the logic contract\n * @param _proxyAdmin Address of the admin for the proxy\n * @param _data Bytecode needed for initialization\n * @return address New instance address\n */\n function deployTokenProxy(\n address _tokenImplementation,\n address _proxyAdmin,\n bytes memory _data\n ) public returns (address) {\n SygnumTokenProxy proxy = new SygnumTokenProxy(_tokenImplementation, _proxyAdmin, _data);\n return address(proxy);\n }\n}\n"},{"file_path":"apps/equity/contracts/token/upgrade/prd/SygnumTokenV2.sol","source_code":"/**\n * @title MetadataUpgrade\n * @author Team 3301 \n * @dev Upgraded SygnumToken. This upgrade allows system accounts to confiscate tokens.\n */\npragma solidity 0.8.8;\n\nimport \"./SygnumTokenV1.sol\";\n\ncontract SygnumTokenV2 is SygnumTokenV1 {\n bool public initializedV2;\n\n error SygnumTokenV2AlreadyInitialized();\n\n // changed back to public for tests\n function initializeContractsAndConstructor(\n string memory _name,\n string memory _symbol,\n uint8 _decimals,\n bytes4 _category,\n string memory _class,\n address _issuer,\n address _baseOperators,\n address _whitelist,\n address _traderOperators,\n address _blockerOperators,\n string memory _tokenURI\n ) public virtual override {\n SygnumTokenV1.initializeContractsAndConstructor(\n _name,\n _symbol,\n _decimals,\n _category,\n _class,\n _issuer,\n _baseOperators,\n _whitelist,\n _traderOperators,\n _blockerOperators,\n _tokenURI\n );\n initializeV2();\n }\n\n function initializeV2() public virtual {\n if (initializedV2) revert SygnumTokenV2AlreadyInitialized();\n initializedV2 = true;\n }\n\n /**\n * @dev Confiscate.\n * @param _confiscatee Account to confiscate funds from.\n * @param _receiver Account to transfer confiscated funds to.\n * @param _amount Amount of tokens to confiscate.\n */\n function confiscate(\n address _confiscatee,\n address _receiver,\n uint256 _amount\n ) public virtual override onlyOperatorOrSystem {\n super._confiscate(_confiscatee, _receiver, _amount);\n emit Confiscated(_confiscatee, _amount, _receiver);\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Blockable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Blockable\n * @author Team 3301 \n * @dev For blocking and unblocking particular user funds.\n */\n\npragma solidity ^0.8.0;\n\nimport \"./ERC20Overload/ERC20.sol\";\nimport \"../../role/blocker/BlockerOperatorable.sol\";\n\ncontract ERC20Blockable is ERC20, BlockerOperatorable {\n using SafeMath for uint256;\n uint256 public totalBlockedBalance;\n\n mapping(address => uint256) public _blockedBalances;\n\n event Blocked(address indexed blocker, address indexed account, uint256 value);\n event UnBlocked(address indexed blocker, address indexed account, uint256 value);\n\n /**\n * @dev Block funds, and move funds from _balances into _blockedBalances.\n * @param _account address to block funds.\n * @param _amount of funds to block.\n */\n function block(address _account, uint256 _amount) public onlyBlockerOrOperator {\n _balances[_account] = _balances[_account].sub(_amount);\n _blockedBalances[_account] = _blockedBalances[_account].add(_amount);\n\n totalBlockedBalance = totalBlockedBalance.add(_amount);\n emit Blocked(msg.sender, _account, _amount);\n }\n\n /**\n * @dev Unblock funds, and move funds from _blockedBalances into _balances.\n * @param _account address to unblock funds.\n * @param _amount of funds to unblock.\n */\n function unblock(address _account, uint256 _amount) public onlyBlockerOrOperator {\n _balances[_account] = _balances[_account].add(_amount);\n _blockedBalances[_account] = _blockedBalances[_account].sub(_amount);\n\n totalBlockedBalance = totalBlockedBalance.sub(_amount);\n emit UnBlocked(msg.sender, _account, _amount);\n }\n\n /**\n * @dev Getter for the amount of blocked balance for a particular address.\n * @param _account address to get blocked balance.\n * @return amount of blocked balance.\n */\n function blockedBalanceOf(address _account) public view returns (uint256) {\n return _blockedBalances[_account];\n }\n\n /**\n * @dev Getter for the total amount of blocked funds for all users.\n * @return amount of total blocked balance.\n */\n function getTotalBlockedBalance() public view returns (uint256) {\n return totalBlockedBalance;\n }\n}\n"},{"file_path":"apps/equity/contracts/token/SygnumTokenProxy.sol","source_code":"/**\n * @title SygnumTokenProxy\n * @author Team 3301 \n * @dev Proxies SygnumToken calls and enables SygnumToken upgradability.\n */\npragma solidity 0.8.8;\n\nimport \"@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol\";\n\ncontract SygnumTokenProxy is TransparentUpgradeableProxy {\n /* solhint-disable no-empty-blocks */\n constructor(\n address implementation,\n address proxyOwnerAddr,\n bytes memory data\n ) TransparentUpgradeableProxy(implementation, proxyOwnerAddr, data) {}\n /* solhint-enable no-empty-blocks */\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/Pausable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title Pausable\n * @author Team 3301 \n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account in the TraderOperatorable\n * contract.\n */\npragma solidity ^0.8.0;\n\nimport \"../role/trader/TraderOperatorable.sol\";\n\nabstract contract Pausable is TraderOperatorable {\n bool internal _paused;\n\n /**\n * @dev Error: \"Pausable: paused\"\n */\n error PausablePaused();\n\n /**\n * @dev Error: \"Pausable: not paused\"\n */\n error PausableNotPaused();\n\n event Paused(address indexed account);\n event Unpaused(address indexed account);\n\n // solhint-disable-next-line func-visibility\n constructor() {\n _paused = false;\n }\n\n /**\n * @dev Reverts if contract is paused.\n */\n modifier whenNotPaused() {\n if (_paused) revert PausablePaused();\n _;\n }\n\n /**\n * @dev Reverts if contract is paused.\n */\n modifier whenPaused() {\n if (!_paused) revert PausableNotPaused();\n _;\n }\n\n /**\n * @dev Called by operator to pause child contract. The contract\n * must not already be paused.\n */\n function pause() public virtual onlyOperatorOrTraderOrSystem whenNotPaused {\n _paused = true;\n emit Paused(msg.sender);\n }\n\n /** @dev Called by operator to pause child contract. The contract\n * must already be paused.\n */\n function unpause() public virtual onlyOperatorOrTraderOrSystem whenPaused {\n _paused = false;\n emit Unpaused(msg.sender);\n }\n\n /**\n * @return If child contract is already paused or not.\n */\n function isPaused() public view virtual returns (bool) {\n return _paused;\n }\n\n /**\n * @return If child contract is not paused.\n */\n function isNotPaused() public view virtual returns (bool) {\n return !_paused;\n }\n}\n"},{"file_path":"apps/equity/contracts/factory/Details.sol","source_code":"/**\n * @title Details\n * @author Team 3301 \n * @notice Shared library for Sygnum token details struct.\n */\n\npragma solidity 0.8.8;\n\nlibrary Details {\n struct TokenDetails {\n string name;\n string symbol;\n uint8 decimals;\n bytes4 category;\n string class;\n address issuer;\n string tokenURI;\n address priceFeed;\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/utils/StorageSlot.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._\n * _Available since v4.9 for `string`, `bytes`._\n */\nlibrary StorageSlot {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n struct StringSlot {\n string value;\n }\n\n struct BytesSlot {\n bytes value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `StringSlot` with member `value` located at `slot`.\n */\n function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n */\n function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := store.slot\n }\n }\n\n /**\n * @dev Returns an `BytesSlot` with member `value` located at `slot`.\n */\n function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n */\n function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := store.slot\n }\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Tradeable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Tradeable\n * @author Team 3301 \n * @dev Trader accounts can approve particular addresses on behalf of a user.\n */\n\npragma solidity ^0.8.0;\n\nimport \"./ERC20Overload/ERC20.sol\";\nimport \"../../role/trader/TraderOperatorable.sol\";\n\ncontract ERC20Tradeable is ERC20, TraderOperatorable {\n /**\n * @dev Trader can approve users balance to a particular address for a particular amount.\n * @param _owner address that approves the funds.\n * @param _spender address that spends the funds.\n * @param _value amount of funds.\n */\n function approveOnBehalf(address _owner, address _spender, uint256 _value) public onlyTrader {\n super._approve(_owner, _spender, _value);\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/utils/Context.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/role/base/Operatorable.sol","source_code":"// SPDX-License-Identifier: Unlicensed\n\n/**\n * @title Operatorable\n * @author Team 3301 \n * @dev Operatorable contract stores the BaseOperators contract address, and modifiers for\n * contracts.\n */\n\npragma solidity ^0.8.0;\n\nimport \"../interface/IBaseOperators.sol\";\nimport \"../../helpers/Initializable.sol\";\n\ncontract Operatorable is Initializable {\n IBaseOperators internal operatorsInst;\n address private operatorsPending;\n\n /**\n * @dev Error: \"Operatorable: caller does not have the operator role\"\n */\n error OperatorableCallerNotOperator();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the admin role\"\n */\n error OperatorableCallerNotAdmin();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the system role\"\n */\n error OperatorableCallerNotSystem();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the multisig role\"\n */\n error OperatorableCallerNotMultisig();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the admin or system role\"\n */\n error OperatorableCallerNotAdminOrSystem();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the operator role nor system\"\n */\n error OperatorableCallerNotOperatorOrSystem();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the relay role\"\n */\n error OperatorableCallerNotRelay();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the operator role nor relay\"\n */\n error OperatorableCallerNotOperatorOrRelay();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the admin role nor relay\"\n */\n error OperatorableCallerNotAdminOrRelay();\n\n /**\n * @dev Error: \"Operatorable: caller does not have the operator role nor system nor relay\"\n */\n error OperatorableCallerNotOperatorOrSystemOrRelay();\n\n /**\n * @dev Error: \"OperatorableCallerNotOperator() nor admin nor relay\"\n */\n error OperatorableCallerNotOperatorOrAdminOrRelay();\n\n /**\n * @dev Error: \"Operatorable: address of new operators contract can not be zero\"\n */\n error OperatorableNewOperatorsZeroAddress();\n\n /**\n * @dev Error: \"Operatorable: should be called from new operators contract\"\n */\n error OperatorableCallerNotOperatorsContract(address _caller);\n\n event OperatorsContractChanged(address indexed caller, address indexed operatorsAddress);\n event OperatorsContractPending(address indexed caller, address indexed operatorsAddress);\n\n /**\n * @dev Reverts if sender does not have operator role associated.\n */\n modifier onlyOperator() {\n if (!isOperator(msg.sender)) revert OperatorableCallerNotOperator();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have admin role associated.\n */\n modifier onlyAdmin() {\n if (!isAdmin(msg.sender)) revert OperatorableCallerNotAdmin();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have system role associated.\n */\n modifier onlySystem() {\n if (!isSystem(msg.sender)) revert OperatorableCallerNotSystem();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have multisig privileges.\n */\n modifier onlyMultisig() {\n if (!isMultisig(msg.sender)) revert OperatorableCallerNotMultisig();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have admin or system role associated.\n */\n modifier onlyAdminOrSystem() {\n if (!isAdminOrSystem(msg.sender)) revert OperatorableCallerNotAdminOrSystem();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have operator or system role associated.\n */\n modifier onlyOperatorOrSystem() {\n if (!isOperatorOrSystem(msg.sender)) revert OperatorableCallerNotOperatorOrSystem();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have the relay role associated.\n */\n modifier onlyRelay() {\n if (!isRelay(msg.sender)) revert OperatorableCallerNotRelay();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have relay or operator role associated.\n */\n modifier onlyOperatorOrRelay() {\n if (!isOperator(msg.sender) && !isRelay(msg.sender)) revert OperatorableCallerNotOperatorOrRelay();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have relay or admin role associated.\n */\n modifier onlyAdminOrRelay() {\n if (!isAdmin(msg.sender) && !isRelay(msg.sender)) revert OperatorableCallerNotAdminOrRelay();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have the operator, or system, or relay role associated.\n */\n modifier onlyOperatorOrSystemOrRelay() {\n if (!isOperator(msg.sender) && !isSystem(msg.sender) && !isRelay(msg.sender))\n revert OperatorableCallerNotOperatorOrSystemOrRelay();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have the operator, or admin, or relay role associated.\n */\n modifier onlyOperatorOrAdminOrRelay() {\n if (!isOperator(msg.sender) && !isAdmin(msg.sender) && !isRelay(msg.sender))\n revert OperatorableCallerNotOperatorOrAdminOrRelay();\n _;\n }\n\n /**\n * @dev Initialization instead of constructor, called once. The setOperatorsContract function can be called only by Admin role with\n * confirmation through the operators contract.\n * @param _baseOperators BaseOperators contract address.\n */\n function initialize(address _baseOperators) public virtual initializer {\n _setOperatorsContract(_baseOperators);\n }\n\n /**\n * @dev Set the new the address of Operators contract, should be confirmed from operators contract by calling confirmFor(addr)\n * where addr is the address of current contract instance. This is done to prevent the case when the new contract address is\n * broken and control of the contract can be lost in such case\n * @param _baseOperators BaseOperators contract address.\n */\n function setOperatorsContract(address _baseOperators) public onlyAdmin {\n if (_baseOperators == address(0)) revert OperatorableNewOperatorsZeroAddress();\n\n operatorsPending = _baseOperators;\n emit OperatorsContractPending(msg.sender, _baseOperators);\n }\n\n /**\n * @dev The function should be called from new operators contract by admin to ensure that operatorsPending address\n * is the real contract address.\n */\n function confirmOperatorsContract() public {\n if (operatorsPending == address(0)) revert OperatorableNewOperatorsZeroAddress();\n\n if (msg.sender != operatorsPending) revert OperatorableCallerNotOperatorsContract(msg.sender);\n\n _setOperatorsContract(operatorsPending);\n }\n\n /**\n * @return The address of the BaseOperators contract.\n */\n function getOperatorsContract() public view returns (address) {\n return address(operatorsInst);\n }\n\n /**\n * @return The pending address of the BaseOperators contract.\n */\n function getOperatorsPending() public view returns (address) {\n return operatorsPending;\n }\n\n /**\n * @return If '_account' has operator privileges.\n */\n function isOperator(address _account) public view returns (bool) {\n return operatorsInst.isOperator(_account);\n }\n\n /**\n * @return If '_account' has admin privileges.\n */\n function isAdmin(address _account) public view returns (bool) {\n return operatorsInst.isAdmin(_account);\n }\n\n /**\n * @return If '_account' has system privileges.\n */\n function isSystem(address _account) public view returns (bool) {\n return operatorsInst.isSystem(_account);\n }\n\n /**\n * @return If '_account' has relay privileges.\n */\n function isRelay(address _account) public view returns (bool) {\n return operatorsInst.isRelay(_account);\n }\n\n /**\n * @return If '_contract' has multisig privileges.\n */\n function isMultisig(address _contract) public view returns (bool) {\n return operatorsInst.isMultisig(_contract);\n }\n\n /**\n * @return If '_account' has admin or system privileges.\n */\n function isAdminOrSystem(address _account) public view returns (bool) {\n return (operatorsInst.isAdmin(_account) || operatorsInst.isSystem(_account));\n }\n\n /**\n * @return If '_account' has operator or system privileges.\n */\n function isOperatorOrSystem(address _account) public view returns (bool) {\n return (operatorsInst.isOperator(_account) || operatorsInst.isSystem(_account));\n }\n\n /** INTERNAL FUNCTIONS */\n function _setOperatorsContract(address _baseOperators) internal {\n if (_baseOperators == address(0)) revert OperatorableNewOperatorsZeroAddress();\n\n operatorsInst = IBaseOperators(_baseOperators);\n emit OperatorsContractChanged(msg.sender, _baseOperators);\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/utils/Address.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n *\n * Furthermore, `isContract` will also return true if the target contract within\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n * which only has an effect at the end of a transaction.\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n *\n * _Available since v4.8._\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n if (success) {\n if (returndata.length == 0) {\n // only check isContract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n require(isContract(target), \"Address: call to non-contract\");\n }\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason or using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n"},{"file_path":"apps/equity/contracts/token/upgrade/prd/SygnumTokenV5.sol","source_code":"/**\n * @title MetadataUpgrade\n * @author Team 3301 \n * @dev Upgraded SygnumToken. This upgrade allows operator accounts to mint and burn tokens while paused.\n */\npragma solidity 0.8.8;\n\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/CLPriceFeedConnector.sol\";\nimport \"./SygnumTokenV4.sol\";\n\ncontract SygnumTokenV5 is SygnumTokenV4, CLPriceFeedConnector {\n bool public initializedV5;\n\n error SygnumTokenV5AlreadyInitialized();\n\n // changed back to public for tests\n function initializeContractsAndConstructor(\n string memory _name,\n string memory _symbol,\n uint8 _decimals,\n bytes4 _category,\n string memory _class,\n address _issuer,\n address _baseOperators,\n address _whitelist,\n address _traderOperators,\n address _blockerOperators,\n string memory _tokenURI,\n address _priceFeed\n ) public virtual {\n SygnumTokenV4.initializeContractsAndConstructor(\n _name,\n _symbol,\n _decimals,\n _category,\n _class,\n _issuer,\n _baseOperators,\n _whitelist,\n _traderOperators,\n _blockerOperators,\n _tokenURI\n );\n initializeV5(_priceFeed);\n }\n\n function initializeV5(address _priceFeed) public virtual {\n if (initializedV5) revert SygnumTokenV5AlreadyInitialized();\n _setPriceFeedOracle(_priceFeed);\n initializedV5 = true;\n }\n\n /**\n * @dev sets the price feed oracle with the provided addresss\n * @param _newPriceFeedOracle the new price feed oracle address\n */\n function setPriceFeedOracle(address _newPriceFeedOracle) public virtual onlyAdmin {\n _setPriceFeedOracle(_newPriceFeedOracle);\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/interface/ICLPriceFeedConnector.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.8;\n\n/**\n * @title IPriceOracle\n * @author Team 3301 \n * @dev Defines the basic interface for a Price oracle.\n */\ninterface ICLPriceFeedConnector {\n /**\n * @dev Returns the asset price in the base currency as per the description\n * @return (int256) latest price of the asset from the price feed\n */\n function getAssetPrice() external view returns (int256);\n\n /**\n * @dev Returns the address or the proxy address of the price feed or data feed oracle configured\n * @return (address) address of the oracle\n */\n function getPriceFeedOracle() external view returns (address);\n\n /**\n * @dev Returns the description of data feed or price feed oracle. Mostly the asset and in which the base currency the asset price is calculated.\n * @return (string) description of price/data feed of the asset\n */\n function getPriceFeedDescription() external view returns (string memory);\n\n /**\n * @dev Returns the decimals of data feed or price feed oracle. asset and in which the base currency the asset price is calculated.\n * @return (uint8) decimals of price/data feed of the asset\n */\n function getPriceFeedDecimals() external view returns (uint8);\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/utils/math/SafeMath.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)\n\npragma solidity ^0.8.0;\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b > a) return (false, 0);\n return (true, a - b);\n }\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a / b);\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n }\n\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `+` operator.\n *\n * Requirements:\n *\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n return a + b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `*` operator.\n *\n * Requirements:\n *\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n return a * b;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator.\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return a % b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {trySub}.\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b <= a, errorMessage);\n return a - b;\n }\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a / b;\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting with custom message when dividing by zero.\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {tryMod}.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a % b;\n }\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Burnable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Burnable\n * @author Team 3301 \n * @dev For burning funds from particular user addresses.\n */\n\npragma solidity ^0.8.0;\n\nimport \"./ERC20Snapshot.sol\";\nimport \"../../role/base/Operatorable.sol\";\n\ncontract ERC20Burnable is ERC20Snapshot, Operatorable {\n /**\n * @dev Overload ERC20 _burnFor, burning funds from a particular users address.\n * @param account address to burn funds from.\n * @param amount of funds to burn.\n */\n\n function _burnFor(address account, uint256 amount) internal virtual override onlyOperator {\n super._burn(account, amount);\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Snapshot.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Snapshot\n * @author Team 3301 \n * @notice Records historical balances.\n */\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\nimport \"./ERC20Overload/ERC20.sol\";\n\ncontract ERC20Snapshot is ERC20 {\n using SafeMath for uint256;\n\n /**\n * @dev `Snapshot` is the structure that attaches a block number to a\n * given value. The block number attached is the one that last changed the value\n */\n struct Snapshot {\n uint256 fromBlock; // `fromBlock` is the block number at which the value was generated from\n uint256 value; // `value` is the amount of tokens at a specific block number\n }\n\n /**\n * @dev `_snapshotBalances` is the map that tracks the balance of each address, in this\n * contract when the balance changes the block number that the change\n * occurred is also included in the map\n */\n mapping(address => Snapshot[]) private _snapshotBalances;\n\n // Tracks the history of the `totalSupply` of the token\n Snapshot[] private _snapshotTotalSupply;\n\n /**\n * @dev Queries the balance of `_owner` at a specific `_blockNumber`\n * @param _owner The address from which the balance will be retrieved\n * @param _blockNumber The block number when the balance is queried\n * @return The balance at `_blockNumber`\n */\n function balanceOfAt(address _owner, uint256 _blockNumber) public view returns (uint256) {\n return getValueAt(_snapshotBalances[_owner], _blockNumber);\n }\n\n /**\n * @dev Total amount of tokens at a specific `_blockNumber`.\n * @param _blockNumber The block number when the totalSupply is queried\n * @return The total amount of tokens at `_blockNumber`\n */\n function totalSupplyAt(uint256 _blockNumber) public view returns (uint256) {\n return getValueAt(_snapshotTotalSupply, _blockNumber);\n }\n\n /**\n * @dev `getValueAt` retrieves the number of tokens at a given block number\n * @param checkpoints The history of values being queried\n * @param _block The block number to retrieve the value at\n * @return The number of tokens being queried\n */\n function getValueAt(Snapshot[] storage checkpoints, uint256 _block) internal view returns (uint256) {\n if (checkpoints.length == 0) return 0;\n\n // Shortcut for the actual value\n if (_block >= checkpoints[checkpoints.length.sub(1)].fromBlock) {\n return checkpoints[checkpoints.length.sub(1)].value;\n }\n\n if (_block < checkpoints[0].fromBlock) {\n return 0;\n }\n\n // Binary search of the value in the array\n uint256 min;\n uint256 max = checkpoints.length.sub(1);\n\n while (max > min) {\n uint256 mid = (max.add(min).add(1)).div(2);\n if (checkpoints[mid].fromBlock <= _block) {\n min = mid;\n } else {\n max = mid.sub(1);\n }\n }\n\n return checkpoints[min].value;\n }\n\n /**\n * @dev `updateValueAtNow` used to update the `_snapshotBalances` map and the `_snapshotTotalSupply`\n * @param checkpoints The history of data being updated\n * @param _value The new number of tokens\n */\n function updateValueAtNow(Snapshot[] storage checkpoints, uint256 _value) internal {\n if ((checkpoints.length == 0) || (checkpoints[checkpoints.length.sub(1)].fromBlock < block.number)) {\n checkpoints.push(Snapshot(block.number, _value));\n } else {\n checkpoints[checkpoints.length.sub(1)].value = _value;\n }\n }\n\n /**\n * @dev Internal function that transfers an amount of the token and assigns it to\n * an account. This encapsulates the modification of balances such that the\n * proper events are emitted.\n * @param to The account that will receive the created tokens.\n * @param value The amount that will be created.\n */\n function transfer(address to, uint256 value) public virtual override returns (bool result) {\n result = super.transfer(to, value);\n updateValueAtNow(_snapshotTotalSupply, totalSupply());\n updateValueAtNow(_snapshotBalances[msg.sender], balanceOf(msg.sender));\n updateValueAtNow(_snapshotBalances[to], balanceOf(to));\n }\n\n /**\n * @dev Internal function that transfers an amount of the token and assigns it to\n * an account. This encapsulates the modification of balances such that the\n * proper events are emitted.\n * @param from The account that funds will be taken from.\n * @param to The account that funds will be given too.\n * @param value The amount of funds to be transferred..\n */\n function transferFrom(address from, address to, uint256 value) public virtual override returns (bool result) {\n result = super.transferFrom(from, to, value);\n updateValueAtNow(_snapshotTotalSupply, totalSupply());\n updateValueAtNow(_snapshotBalances[from], balanceOf(from));\n updateValueAtNow(_snapshotBalances[to], balanceOf(to));\n }\n\n /**\n * @dev Internal function that confiscates an amount of the token and assigns it to\n * an account. This encapsulates the modification of balances such that the\n * proper events are emitted.\n * @param confiscatee The account that funds will be taken from.\n * @param receiver The account that funds will be given too.\n * @param amount The amount of funds to be transferred..\n */\n function _confiscate(address confiscatee, address receiver, uint256 amount) internal virtual {\n super._transfer(confiscatee, receiver, amount);\n updateValueAtNow(_snapshotTotalSupply, totalSupply());\n updateValueAtNow(_snapshotBalances[confiscatee], balanceOf(confiscatee));\n updateValueAtNow(_snapshotBalances[receiver], balanceOf(receiver));\n }\n\n /**\n * @dev Internal function that mints an amount of the token and assigns it to\n * an account. This encapsulates the modification of balances such that the\n * proper events are emitted.\n * @param account The account that will receive the created tokens.\n * @param amount The amount that will be created.\n */\n function _mint(address account, uint256 amount) internal virtual override {\n super._mint(account, amount);\n updateValueAtNow(_snapshotTotalSupply, totalSupply());\n updateValueAtNow(_snapshotBalances[account], balanceOf(account));\n }\n\n /**\n * @dev Internal function that burns an amount of the token of a given\n * account.\n * @param account The account whose tokens will be burnt.\n * @param amount The amount that will be burnt.\n */\n function _burn(address account, uint256 amount) internal virtual override {\n super._burn(account, amount);\n updateValueAtNow(_snapshotTotalSupply, totalSupply());\n updateValueAtNow(_snapshotBalances[account], balanceOf(account));\n }\n\n /**\n * @dev Internal function that burns an amount of the token of a given\n * account.\n * @param account The account whose tokens will be burnt.\n * @param amount The amount that will be burnt.\n */\n function _burnFor(address account, uint256 amount) internal virtual {\n super._burn(account, amount);\n updateValueAtNow(_snapshotTotalSupply, totalSupply());\n updateValueAtNow(_snapshotBalances[account], balanceOf(account));\n }\n\n /**\n * @dev Internal function that burns an amount of the token of a given\n * account, deducting from the sender's allowance for said account. Uses the\n * internal burn function.\n * @param account The account whose tokens will be burnt.\n * @param amount The amount that will be burnt.\n */\n function _burnFrom(address account, uint256 amount) internal virtual override {\n super._burnFrom(account, amount);\n updateValueAtNow(_snapshotTotalSupply, totalSupply());\n updateValueAtNow(_snapshotBalances[account], balanceOf(account));\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Mintable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Mintable\n * @author Team 3301 \n * @dev For blocking and unblocking particular user funds.\n */\n\npragma solidity ^0.8.0;\n\nimport \"./ERC20Overload/ERC20.sol\";\nimport \"../../role/base/Operatorable.sol\";\n\ncontract ERC20Mintable is ERC20, Operatorable {\n /**\n * @dev Error: \"ERC20Mintable: amount has to be greater than 0\"\n */\n error ERC20MintableZeroMintAmount();\n\n /**\n * @dev Overload _mint to ensure only operator or system can mint funds.\n * @param account address that will recieve new funds.\n * @param amount of funds to be minted.\n */\n function _mint(address account, uint256 amount) internal virtual override onlyOperatorOrSystem {\n if (amount <= 0) revert ERC20MintableZeroMintAmount();\n\n super._mint(account, amount);\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/proxy/Proxy.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n /**\n * @dev Delegates the current call to `implementation`.\n *\n * This function does not return to its internal call site, it will return directly to the external caller.\n */\n function _delegate(address implementation) internal virtual {\n assembly {\n // Copy msg.data. We take full control of memory in this inline assembly\n // block because it will not return to Solidity code. We overwrite the\n // Solidity scratch pad at memory position 0.\n calldatacopy(0, 0, calldatasize())\n\n // Call the implementation.\n // out and outsize are 0 because we don't know the size yet.\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n // Copy the returned data.\n returndatacopy(0, 0, returndatasize())\n\n switch result\n // delegatecall returns 0 on error.\n case 0 {\n revert(0, returndatasize())\n }\n default {\n return(0, returndatasize())\n }\n }\n }\n\n /**\n * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n * and {_fallback} should delegate.\n */\n function _implementation() internal view virtual returns (address);\n\n /**\n * @dev Delegates the current call to the address returned by `_implementation()`.\n *\n * This function does not return to its internal call site, it will return directly to the external caller.\n */\n function _fallback() internal virtual {\n _beforeFallback();\n _delegate(_implementation());\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n * function in the contract matches the call data.\n */\n fallback() external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n * is empty.\n */\n receive() external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n * call, or as part of the Solidity `fallback` or `receive` functions.\n *\n * If overridden should call `super._beforeFallback()`.\n */\n function _beforeFallback() internal virtual {}\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/proxy/ERC1967/ERC1967Proxy.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Proxy.sol\";\nimport \"./ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\n * implementation address that can be changed. This address is stored in storage in the location specified by\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\n * implementation behind the proxy.\n */\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\n /**\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\n *\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\n * function call, and allows initializing the storage of the proxy like a Solidity constructor.\n */\n constructor(address _logic, bytes memory _data) payable {\n _upgradeToAndCall(_logic, _data, false);\n }\n\n /**\n * @dev Returns the current implementation address.\n */\n function _implementation() internal view virtual override returns (address impl) {\n return ERC1967Upgrade._getImplementation();\n }\n}\n"},{"file_path":"apps/equity/contracts/token/ERC20/ERC20Detailed.sol","source_code":"/**\n * @title ERC20Detailed\n * @author OpenZeppelin-Solidity = \"openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol\", and rmeoval\n * of IERC20 due to \" contract binary not set. Can't deploy new instance.\n * This contract may be abstract, not implement an abstract parent's methods completely\n * or not invoke an inherited contract's constructor correctly\"\n */\n\npragma solidity 0.8.8;\n\n/**\n * @dev Optional functions from the ERC20 standard.\n */\ncontract ERC20Detailed {\n string internal _name;\n string internal _symbol;\n uint8 internal _decimals;\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei.\n *\n * > Note that this information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * `IERC20.balanceOf` and `IERC20.transfer`.\n */\n function decimals() public view virtual returns (uint8) {\n return _decimals;\n }\n}\n"},{"file_path":"apps/equity/contracts/token/upgrade/prd/SygnumTokenLatest.sol","source_code":"/**\n * @title MetadataUpgrade\n * @author Team 3301 \n * @dev Latest version of SygnumToken.\n */\npragma solidity 0.8.8;\n\nimport \"./SygnumTokenV5.sol\";\n\ncontract SygnumTokenLatest is SygnumTokenV5 {}\n"},{"file_path":"dependencies/@chainlink-contracts-1.3.0/src/v0.8/shared/interfaces/AggregatorInterface.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// solhint-disable-next-line interface-starts-with-i\ninterface AggregatorInterface {\n function latestAnswer() external view returns (int256);\n\n function latestTimestamp() external view returns (uint256);\n\n function latestRound() external view returns (uint256);\n\n function getAnswer(uint256 roundId) external view returns (int256);\n\n function getTimestamp(uint256 roundId) external view returns (uint256);\n\n event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 updatedAt);\n\n event NewRound(uint256 indexed roundId, address indexed startedBy, uint256 startedAt);\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/proxy/transparent/TransparentUpgradeableProxy.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/transparent/TransparentUpgradeableProxy.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC1967/ERC1967Proxy.sol\";\n\n/**\n * @dev Interface for {TransparentUpgradeableProxy}. In order to implement transparency, {TransparentUpgradeableProxy}\n * does not implement this interface directly, and some of its functions are implemented by an internal dispatch\n * mechanism. The compiler is unaware that these functions are implemented by {TransparentUpgradeableProxy} and will not\n * include them in the ABI so this interface must be used to interact with it.\n */\ninterface ITransparentUpgradeableProxy is IERC1967 {\n function admin() external view returns (address);\n\n function implementation() external view returns (address);\n\n function changeAdmin(address) external;\n\n function upgradeTo(address) external;\n\n function upgradeToAndCall(address, bytes memory) external payable;\n}\n\n/**\n * @dev This contract implements a proxy that is upgradeable by an admin.\n *\n * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector\n * clashing], which can potentially be used in an attack, this contract uses the\n * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two\n * things that go hand in hand:\n *\n * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if\n * that call matches one of the admin functions exposed by the proxy itself.\n * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the\n * implementation. If the admin tries to call a function on the implementation it will fail with an error that says\n * \"admin cannot fallback to proxy target\".\n *\n * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing\n * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due\n * to sudden errors when trying to call a function from the proxy implementation.\n *\n * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,\n * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.\n *\n * NOTE: The real interface of this proxy is that defined in `ITransparentUpgradeableProxy`. This contract does not\n * inherit from that interface, and instead the admin functions are implicitly implemented using a custom dispatch\n * mechanism in `_fallback`. Consequently, the compiler will not produce an ABI for this contract. This is necessary to\n * fully implement transparency without decoding reverts caused by selector clashes between the proxy and the\n * implementation.\n *\n * WARNING: It is not recommended to extend this contract to add additional external functions. If you do so, the compiler\n * will not check that there are no selector conflicts, due to the note above. A selector clash between any new function\n * and the functions declared in {ITransparentUpgradeableProxy} will be resolved in favor of the new one. This could\n * render the admin operations inaccessible, which could prevent upgradeability. Transparency may also be compromised.\n */\ncontract TransparentUpgradeableProxy is ERC1967Proxy {\n /**\n * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and\n * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.\n */\n constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {\n _changeAdmin(admin_);\n }\n\n /**\n * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.\n *\n * CAUTION: This modifier is deprecated, as it could cause issues if the modified function has arguments, and the\n * implementation provides a function with the same selector.\n */\n modifier ifAdmin() {\n if (msg.sender == _getAdmin()) {\n _;\n } else {\n _fallback();\n }\n }\n\n /**\n * @dev If caller is the admin process the call internally, otherwise transparently fallback to the proxy behavior\n */\n function _fallback() internal virtual override {\n if (msg.sender == _getAdmin()) {\n bytes memory ret;\n bytes4 selector = msg.sig;\n if (selector == ITransparentUpgradeableProxy.upgradeTo.selector) {\n ret = _dispatchUpgradeTo();\n } else if (selector == ITransparentUpgradeableProxy.upgradeToAndCall.selector) {\n ret = _dispatchUpgradeToAndCall();\n } else if (selector == ITransparentUpgradeableProxy.changeAdmin.selector) {\n ret = _dispatchChangeAdmin();\n } else if (selector == ITransparentUpgradeableProxy.admin.selector) {\n ret = _dispatchAdmin();\n } else if (selector == ITransparentUpgradeableProxy.implementation.selector) {\n ret = _dispatchImplementation();\n } else {\n revert(\"TransparentUpgradeableProxy: admin cannot fallback to proxy target\");\n }\n assembly {\n return(add(ret, 0x20), mload(ret))\n }\n } else {\n super._fallback();\n }\n }\n\n /**\n * @dev Returns the current admin.\n *\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n */\n function _dispatchAdmin() private returns (bytes memory) {\n _requireZeroValue();\n\n address admin = _getAdmin();\n return abi.encode(admin);\n }\n\n /**\n * @dev Returns the current implementation.\n *\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\n */\n function _dispatchImplementation() private returns (bytes memory) {\n _requireZeroValue();\n\n address implementation = _implementation();\n return abi.encode(implementation);\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _dispatchChangeAdmin() private returns (bytes memory) {\n _requireZeroValue();\n\n address newAdmin = abi.decode(msg.data[4:], (address));\n _changeAdmin(newAdmin);\n\n return \"\";\n }\n\n /**\n * @dev Upgrade the implementation of the proxy.\n */\n function _dispatchUpgradeTo() private returns (bytes memory) {\n _requireZeroValue();\n\n address newImplementation = abi.decode(msg.data[4:], (address));\n _upgradeToAndCall(newImplementation, bytes(\"\"), false);\n\n return \"\";\n }\n\n /**\n * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified\n * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the\n * proxied contract.\n */\n function _dispatchUpgradeToAndCall() private returns (bytes memory) {\n (address newImplementation, bytes memory data) = abi.decode(msg.data[4:], (address, bytes));\n _upgradeToAndCall(newImplementation, data, true);\n\n return \"\";\n }\n\n /**\n * @dev Returns the current admin.\n *\n * CAUTION: This function is deprecated. Use {ERC1967Upgrade-_getAdmin} instead.\n */\n function _admin() internal view virtual returns (address) {\n return _getAdmin();\n }\n\n /**\n * @dev To keep this contract fully transparent, all `ifAdmin` functions must be payable. This helper is here to\n * emulate some proxy functions being non-payable while still allowing value to pass through.\n */\n function _requireZeroValue() private {\n require(msg.value == 0);\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/proxy/beacon/IBeacon.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Freezable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Freezable\n * @author Team 3301 \n * @dev Overloading ERC20 functions to ensure client addresses are not frozen for particular actions.\n */\n\npragma solidity ^0.8.0;\n\nimport \"./ERC20Overload/ERC20.sol\";\nimport \"../Freezable.sol\";\n\ncontract ERC20Freezable is ERC20, Freezable {\n /**\n * @dev Overload transfer function to ensure sender and receiver have not been frozen.\n * @param to address that recieves the funds.\n * @param value amount of funds.\n */\n function transfer(\n address to,\n uint256 value\n ) public virtual override whenNotFrozen(msg.sender) whenNotFrozen(to) returns (bool) {\n return super.transfer(to, value);\n }\n\n /**\n * @dev Overload approve function to ensure sender and receiver have not been frozen.\n * @param spender address that can spend the funds.\n * @param value amount of funds.\n */\n function approve(\n address spender,\n uint256 value\n ) public virtual override whenNotFrozen(msg.sender) whenNotFrozen(spender) returns (bool) {\n return super.approve(spender, value);\n }\n\n /**\n * @dev Overload transferFrom function to ensure sender, approver and receiver have not been frozen.\n * @param from address that funds will be transferred from.\n * @param to address that funds will be transferred to.\n * @param value amount of funds.\n */\n function transferFrom(\n address from,\n address to,\n uint256 value\n ) public virtual override whenNotFrozen(msg.sender) whenNotFrozen(from) whenNotFrozen(to) returns (bool) {\n return super.transferFrom(from, to, value);\n }\n\n /**\n * @dev Overload increaseAllowance function to ensure sender and spender have not been frozen.\n * @param spender address that will be allowed to transfer funds.\n * @param addedValue amount of funds to added to current allowance.\n */\n function increaseAllowance(\n address spender,\n uint256 addedValue\n ) public virtual override whenNotFrozen(msg.sender) whenNotFrozen(spender) returns (bool) {\n return super.increaseAllowance(spender, addedValue);\n }\n\n /**\n * @dev Overload decreaseAllowance function to ensure sender and spender have not been frozen.\n * @param spender address that will be allowed to transfer funds.\n * @param subtractedValue amount of funds to be deducted to current allowance.\n */\n function decreaseAllowance(\n address spender,\n uint256 subtractedValue\n ) public virtual override whenNotFrozen(msg.sender) whenNotFrozen(spender) returns (bool) {\n return super.decreaseAllowance(spender, subtractedValue);\n }\n\n /**\n * @dev Overload _burnfrom function to ensure sender and user to be burned from have not been frozen.\n * @param account account that funds will be burned from.\n * @param amount amount of funds to be burned.\n */\n function _burnFrom(\n address account,\n uint256 amount\n ) internal virtual override whenNotFrozen(msg.sender) whenNotFrozen(account) {\n super._burnFrom(account, amount);\n }\n}\n"},{"file_path":"apps/equity/contracts/token/SygnumToken.sol","source_code":"/**\n * @title SygnumToken\n * @author Team 3301 \n * @notice ERC20 token with additional features.\n */\n\npragma solidity 0.8.8;\n\nimport \"./ERC20/ERC20SygnumDetailed.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Whitelist.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Pausable.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Mintable.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Burnable.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Freezable.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Destroyable.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Snapshot.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Tradeable.sol\";\nimport \"@sygnum/solidity-base-contracts/contracts/helpers/ERC20/ERC20Blockable.sol\";\n\ncontract SygnumToken is\n ERC20Snapshot,\n ERC20SygnumDetailed,\n ERC20Pausable,\n ERC20Mintable,\n ERC20Whitelist,\n ERC20Tradeable,\n ERC20Blockable,\n ERC20Burnable,\n ERC20Freezable,\n ERC20Destroyable\n{\n /**\n * @dev Error: \"SygnumToken: Account must not be frozen.\"\n */\n error SygnumTokenAccountFrozen(address _account);\n\n /**\n * @dev Error: \"SygnumToken: Account must not be frozen if system calling.\"\n */\n error SygnumTokenSystemCallAccountFrozen(address _account);\n\n /**\n * @dev Error: \"SygnumToken: values and recipients are not equal.\"\n */\n error SygnumTokenUnequalArrayLengths();\n\n /**\n * @dev Error: \"SygnumToken: batch count is greater than BATCH_LIMIT.\"\n */\n error SygnumTokenBatchCountExceedsLimit();\n\n /**\n * @dev Error: \"SygnumToken: initialize() disabled\"\n */\n error SygnumTokenDisabledInitialize();\n\n event Minted(address indexed minter, address indexed account, uint256 value);\n event Burned(address indexed burner, uint256 value);\n event BurnedFor(address indexed burner, address indexed account, uint256 value);\n event Confiscated(address indexed account, uint256 amount, address indexed receiver);\n\n uint16 internal constant BATCH_LIMIT = 256;\n\n /**\n * @dev Initializer obligatorily overriding the initializer() functions\n * of the base contracts. For the moment, just used to disable\n * inherited functions.\n */\n function initialize(\n address,\n address\n ) public virtual override(BlockerOperatorable, TraderOperatorable, Whitelistable) {\n revert SygnumTokenDisabledInitialize();\n }\n\n /**\n * @dev Initialize contracts.\n * @param _baseOperators Base operators contract address.\n * @param _whitelist Whitelist contract address.\n * @param _traderOperators Trader operators contract address.\n * @param _blockerOperators Blocker operators contract address.\n */\n function initializeContractsAndConstructor(\n string memory _name,\n string memory _symbol,\n uint8 _decimals,\n bytes4 _category,\n string memory _class,\n address _issuer,\n address _baseOperators,\n address _whitelist,\n address _traderOperators,\n address _blockerOperators\n ) public virtual initializer {\n super.initialize(_baseOperators);\n _setWhitelistContract(_whitelist);\n _setTraderOperatorsContract(_traderOperators);\n _setBlockerOperatorsContract(_blockerOperators);\n _setDetails(_name, _symbol, _decimals, _category, _class, _issuer);\n }\n\n /**\n * @dev Burn.\n * @param _amount Amount of tokens to burn.\n */\n function burn(uint256 _amount) public virtual {\n if (isFrozen(msg.sender)) revert SygnumTokenAccountFrozen(msg.sender);\n _burn(msg.sender, _amount);\n emit Burned(msg.sender, _amount);\n }\n\n /**\n * @dev BurnFor.\n * @param _account Address to burn tokens for.\n * @param _amount Amount of tokens to burn.\n */\n function burnFor(address _account, uint256 _amount) public virtual {\n _burnFor(_account, _amount);\n emit BurnedFor(msg.sender, _account, _amount);\n }\n\n /**\n * @dev BurnFrom.\n * @param _account Address to burn tokens from.\n * @param _amount Amount of tokens to burn.\n */\n function burnFrom(address _account, uint256 _amount) public virtual {\n _burnFrom(_account, _amount);\n emit Burned(_account, _amount);\n }\n\n /**\n * @dev Mint.\n * @param _account Address to mint tokens to.\n * @param _amount Amount to mint.\n */\n function mint(address _account, uint256 _amount) public virtual {\n if (isSystem(msg.sender)) {\n if (isFrozen(_account)) revert SygnumTokenSystemCallAccountFrozen(_account);\n }\n _mint(_account, _amount);\n emit Minted(msg.sender, _account, _amount);\n }\n\n /**\n * @dev Confiscate.\n * @param _confiscatee Account to confiscate funds from.\n * @param _receiver Account to transfer confiscated funds to.\n * @param _amount Amount of tokens to confiscate.\n */\n function confiscate(\n address _confiscatee,\n address _receiver,\n uint256 _amount\n ) public virtual onlyOperator whenNotPaused whenWhitelisted(_receiver) whenWhitelisted(_confiscatee) {\n _confiscate(_confiscatee, _receiver, _amount);\n emit Confiscated(_confiscatee, _amount, _receiver);\n }\n\n /**\n * @dev Batch burn for.\n * @param _amounts Array of all values to burn.\n * @param _accounts Array of all addresses to burn from.\n */\n function batchBurnFor(address[] memory _accounts, uint256[] memory _amounts) public virtual {\n if (_accounts.length != _amounts.length) revert SygnumTokenUnequalArrayLengths();\n if (_accounts.length > BATCH_LIMIT) revert SygnumTokenBatchCountExceedsLimit();\n\n for (uint256 i = 0; i < _accounts.length; ++i) {\n burnFor(_accounts[i], _amounts[i]);\n }\n }\n\n /**\n * @dev Batch mint.\n * @param _accounts Array of all addresses to mint to.\n * @param _amounts Array of all values to mint.\n */\n function batchMint(address[] memory _accounts, uint256[] memory _amounts) public virtual {\n if (_accounts.length != _amounts.length) revert SygnumTokenUnequalArrayLengths();\n if (_accounts.length > BATCH_LIMIT) revert SygnumTokenBatchCountExceedsLimit();\n\n for (uint256 i = 0; i < _accounts.length; ++i) {\n mint(_accounts[i], _amounts[i]);\n }\n }\n\n /**\n * @dev Batch confiscate to a maximum of 256 addresses.\n * @param _confiscatees array of addresses whose funds are being confiscated\n * @param _receivers array of addresses who's receiving the funds\n * @param _values array of values of funds being confiscated\n */\n function batchConfiscate(\n address[] memory _confiscatees,\n address[] memory _receivers,\n uint256[] memory _values\n ) public virtual {\n if (_confiscatees.length != _values.length || _receivers.length != _values.length)\n revert SygnumTokenUnequalArrayLengths();\n if (_confiscatees.length > BATCH_LIMIT) revert SygnumTokenBatchCountExceedsLimit();\n\n for (uint256 i = 0; i < _confiscatees.length; ++i) {\n confiscate(_confiscatees[i], _receivers[i], _values[i]);\n }\n }\n\n // FORCE OVERRIDE FUNCTIONS\n\n function transferFrom(\n address from,\n address to,\n uint256 value\n ) public virtual override(ERC20, ERC20Freezable, ERC20Pausable, ERC20Snapshot, ERC20Whitelist) returns (bool) {\n return super.transferFrom(from, to, value);\n }\n\n function transfer(\n address to,\n uint256 value\n ) public virtual override(ERC20, ERC20Freezable, ERC20Pausable, ERC20Snapshot, ERC20Whitelist) returns (bool) {\n return super.transfer(to, value);\n }\n\n function increaseAllowance(\n address spender,\n uint256 addedValue\n ) public virtual override(ERC20, ERC20Freezable, ERC20Pausable, ERC20Whitelist) returns (bool) {\n return super.increaseAllowance(spender, addedValue);\n }\n\n function decreaseAllowance(\n address spender,\n uint256 subtractedValue\n ) public virtual override(ERC20, ERC20Freezable, ERC20Pausable, ERC20Whitelist) returns (bool) {\n return super.decreaseAllowance(spender, subtractedValue);\n }\n\n function approve(\n address spender,\n uint256 value\n ) public virtual override(ERC20, ERC20Freezable, ERC20Pausable, ERC20Whitelist) returns (bool) {\n return super.approve(spender, value);\n }\n\n function _burn(\n address account,\n uint256 value\n ) internal virtual override(ERC20, ERC20Snapshot, ERC20Pausable, ERC20Whitelist) {\n super._burn(account, value);\n }\n\n /**\n * @dev Overload _burnFrom function to ensure contract has not been paused.\n * @param account address that funds will be burned from allowance.\n * @param amount amount of funds that will be burned.\n */\n function _burnFrom(\n address account,\n uint256 amount\n ) internal virtual override(ERC20, ERC20Snapshot, ERC20Pausable, ERC20Whitelist, ERC20Freezable) {\n super._burnFrom(account, amount);\n }\n\n /**\n * @dev Overload _mint function to ensure contract has not been paused.\n * @param account address that funds will be minted to.\n * @param amount amount of funds that will be minted.\n */\n function _mint(\n address account,\n uint256 amount\n ) internal virtual override(ERC20, ERC20Snapshot, ERC20Pausable, ERC20Whitelist, ERC20Mintable) {\n super._mint(account, amount);\n }\n\n function _burnFor(address account, uint256 amount) internal virtual override(ERC20Snapshot, ERC20Burnable) {\n super._burnFor(account, amount);\n }\n}\n"},{"file_path":"dependencies/@chainlink-contracts-1.3.0/src/v0.8/shared/interfaces/AggregatorV3Interface.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// solhint-disable-next-line interface-starts-with-i\ninterface AggregatorV3Interface {\n function decimals() external view returns (uint8);\n\n function description() external view returns (string memory);\n\n function version() external view returns (uint256);\n\n function getRoundData(\n uint80 _roundId\n ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\n\n function latestRoundData()\n external\n view\n returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/ERC20/ERC20Destroyable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @title ERC20Destroyable\n * @author Team 3301 \n * @notice Allows operator to destroy contract.\n */\n\npragma solidity ^0.8.0;\n\nimport \"../../role/base/Operatorable.sol\";\n\ncontract ERC20Destroyable is Operatorable {\n event Destroyed(address indexed caller, address indexed account, address indexed contractAddress);\n\n function destroy(address payable to) public onlyOperator {\n emit Destroyed(msg.sender, to, address(this));\n selfdestruct(to);\n }\n}\n"},{"file_path":"apps/baseContracts/contracts/helpers/Initializable.sol","source_code":"// SPDX-License-Identifier: UNLICENSED\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\n\npragma solidity ^0.8.0;\n\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n */\n bool private initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized();\n\n /**\n * @dev Error: \"Initializable: Contract instance has already been initialized\"\n */\n error InitializableContractAlreadyInitialized();\n\n /**\n * @dev Error: \"Initializable: Contract instance is initializing\"\n */\n error InitializableContractIsInitializing();\n\n /**\n * @dev Modifier to use in the initializer function of a contract.\n */\n modifier initializer() {\n bool isTopLevelCall = !initializing;\n\n if (isTopLevelCall && !isConstructor() && initialized) revert InitializableContractAlreadyInitialized();\n\n if (isTopLevelCall) {\n initializing = true;\n initialized = true;\n }\n\n _;\n\n if (isTopLevelCall) {\n initializing = false;\n emit Initialized();\n }\n }\n\n /**\n * @dev Returns true if and only if the function is running in the constructor\n */\n function isConstructor() private view returns (bool) {\n // extcodesize checks the size of the code stored in an address, and\n // address returns the current address. Since the code is still not\n // deployed when running a constructor, any checks on its code size will\n // yield zero, making it an effective way to detect if a contract is\n // under construction or not.\n address self = address(this);\n uint256 cs;\n // solhint-disable-next-line no-inline-assembly\n assembly {\n cs := extcodesize(self)\n }\n return cs == 0;\n }\n\n /**\n * @dev Function that returns wheteher a contract is already initialized. Returns `initialized`\n */\n function isInitialized() public view virtual returns (bool) {\n return initialized;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n *\n * Emits an {Initialized} event the first time it is successfully executed.\n */\n function _disableInitializers() internal virtual {\n if (initializing) revert InitializableContractIsInitializing();\n if (!initialized) {\n initialized = true;\n emit Initialized();\n }\n }\n\n // Reserved storage space to allow for layout changes in the future.\n uint256[50] private ______gap;\n}\n"},{"file_path":"apps/baseContracts/contracts/role/blocker/BlockerOperatorable.sol","source_code":"// SPDX-License-Identifier: Unlicensed\n\n/**\n * @title BlockerOperatorable\n * @author Team 3301 \n * @dev BlockerOperatorable contract stores BlockerOperators contract address, and modifiers for\n * contracts.\n */\n\npragma solidity ^0.8.0;\n\nimport \"../interface/IBlockerOperators.sol\";\nimport \"../base/Operatorable.sol\";\nimport \"../../helpers/Initializable.sol\";\n\ncontract BlockerOperatorable is Operatorable {\n IBlockerOperators internal blockerOperatorsInst;\n address private blockerOperatorsPending;\n\n /**\n * @dev Error: \"BlockerOperatorable: caller is not blocker role\"\n */\n error BlockerOperatorableCallerNotBlocker();\n\n /**\n * @dev Error: \"BlockerOperatorable: caller is not blocker or operator role\"\n */\n error BlockerOperatorableCallerNotBlockerOrOperator();\n\n /**\n * @dev Error: \"BlockerOperatorable: address of new blockerOperators contract can not be zero.\"\n */\n error BlockerOperatorableNewBlockerOperatorsAddressZero();\n\n /**\n * @dev Error: \"BlockerOperatorable: address of pending blockerOperators contract can not be zero\"\n */\n error BlockerOperatorablePendingBlockerOperatorsAddressZero();\n\n /**\n * @dev Error: \"BlockerOperatorable: should be called from new blockerOperators contract\"\n */\n error BlockerOperatorableCallerNotNewBlockerOperator();\n\n event BlockerOperatorsContractChanged(address indexed caller, address indexed blockerOperatorAddress);\n event BlockerOperatorsContractPending(address indexed caller, address indexed blockerOperatorAddress);\n\n /**\n * @dev Reverts if sender does not have the blocker role associated.\n */\n modifier onlyBlocker() {\n if (!isBlocker(msg.sender)) revert BlockerOperatorableCallerNotBlocker();\n _;\n }\n\n /**\n * @dev Reverts if sender does not have the blocker or operator role associated.\n */\n modifier onlyBlockerOrOperator() {\n if (!isBlocker(msg.sender) && !isOperator(msg.sender)) revert BlockerOperatorableCallerNotBlockerOrOperator();\n _;\n }\n\n /**\n * @dev Initialization instead of constructor, called once. The setBlockerOperatorsContract function can be called only by Admin role with\n * confirmation through the operators contract.\n * @param _baseOperators BaseOperators contract address.\n * @param _blockerOperators BlockerOperators contract address.\n */\n function initialize(address _baseOperators, address _blockerOperators) public virtual initializer {\n super.initialize(_baseOperators);\n _setBlockerOperatorsContract(_blockerOperators);\n }\n\n /**\n * @dev Set the new the address of BlockerOperators contract, should be confirmed from BlockerOperators contract by calling confirmFor(addr)\n * where addr is the address of current contract instance. This is done to prevent the case when the new contract address is\n * broken and control of the contract can be lost in such case.\n * @param _blockerOperators BlockerOperators contract address.\n */\n function setBlockerOperatorsContract(address _blockerOperators) public onlyAdmin {\n if (_blockerOperators == address(0)) revert BlockerOperatorableNewBlockerOperatorsAddressZero();\n\n blockerOperatorsPending = _blockerOperators;\n emit BlockerOperatorsContractPending(msg.sender, _blockerOperators);\n }\n\n /**\n * @dev The function should be called from new BlockerOperators contract by admin to insure that blockerOperatorsPending address\n * is the real contract address.\n */\n function confirmBlockerOperatorsContract() public {\n if (blockerOperatorsPending == address(0)) revert BlockerOperatorablePendingBlockerOperatorsAddressZero();\n if (msg.sender != blockerOperatorsPending) revert BlockerOperatorableCallerNotNewBlockerOperator();\n\n _setBlockerOperatorsContract(blockerOperatorsPending);\n }\n\n /**\n * @return The address of the BlockerOperators contract.\n */\n function getBlockerOperatorsContract() public view returns (address) {\n return address(blockerOperatorsInst);\n }\n\n /**\n * @return The pending BlockerOperators contract address\n */\n function getBlockerOperatorsPending() public view returns (address) {\n return blockerOperatorsPending;\n }\n\n /**\n * @return If '_account' has blocker privileges.\n */\n function isBlocker(address _account) public view returns (bool) {\n return blockerOperatorsInst.isBlocker(_account);\n }\n\n /** INTERNAL FUNCTIONS */\n function _setBlockerOperatorsContract(address _blockerOperators) internal {\n if (_blockerOperators == address(0)) revert BlockerOperatorableNewBlockerOperatorsAddressZero();\n\n blockerOperatorsInst = IBlockerOperators(_blockerOperators);\n emit BlockerOperatorsContractChanged(msg.sender, _blockerOperators);\n }\n}\n"},{"file_path":"apps/equity/contracts/factory/TokenDeployer.sol","source_code":"/**\n * @title TokenDeployer\n * @author Team 3301 \n * @dev Library to deploy and initialize a new instance of Sygnum Equity Token.\n * This is commonly used by a TokenFactory to automatically deploy and configure\n */\n\npragma solidity 0.8.8;\n\nimport \"../token/SygnumToken.sol\";\nimport \"../token/upgrade/prd/SygnumTokenLatest.sol\";\nimport \"./Details.sol\";\n\nlibrary TokenDeployer {\n /**\n * @dev Initialize a token contracts.\n * @param _proxy Address of the proxy\n * @param _baseOperators Address of the base operator role contract\n * @param _whitelist Address of the whitelist contract\n * @param _traderOperators Address of the trader operator role contract\n * @param _blockerOperators Address of the blocker operator role contract\n * @param _details token details as defined by the TokenDetails struct\n */\n function initializeToken(\n address _proxy,\n address _baseOperators,\n address _whitelist,\n address _traderOperators,\n address _blockerOperators,\n Details.TokenDetails memory _details\n ) public {\n SygnumTokenLatest(_proxy).initializeContractsAndConstructor(\n _details.name,\n _details.symbol,\n _details.decimals,\n _details.category,\n _details.class,\n _details.issuer,\n _baseOperators,\n _whitelist,\n _traderOperators,\n _blockerOperators,\n _details.tokenURI,\n _details.priceFeed\n );\n }\n}\n"},{"file_path":"dependencies/@openzeppelin-contracts-4.9.3/interfaces/IERC1967.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.\n *\n * _Available since v4.8.3._\n */\ninterface IERC1967 {\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Emitted when the beacon is changed.\n */\n event BeaconUpgraded(address indexed beacon);\n}\n"},{"file_path":"apps/baseContracts/contracts/role/interface/IBaseOperators.sol","source_code":"// SPDX-License-Identifier: Unlicensed\n\n/**\n * @title IBaseOperators\n * @notice Interface for BaseOperators contract\n */\n\npragma solidity ^0.8.0;\n\ninterface IBaseOperators {\n function isOperator(address _account) external view returns (bool);\n\n function isAdmin(address _account) external view returns (bool);\n\n function isSystem(address _account) external view returns (bool);\n\n function isRelay(address _account) external view returns (bool);\n\n function isMultisig(address _contract) external view returns (bool);\n\n function confirmFor(address _address) external;\n\n function addOperator(address _account) external;\n\n function removeOperator(address _account) external;\n\n function addAdmin(address _account) external;\n\n function removeAdmin(address _account) external;\n\n function addSystem(address _account) external;\n\n function removeSystem(address _account) external;\n\n function addRelay(address _account) external;\n\n function removeRelay(address _account) external;\n\n function addOperatorAndAdmin(address _account) external;\n\n function removeOperatorAndAdmin(address _account) external;\n}\n"},{"file_path":"apps/baseContracts/contracts/role/interface/ITraderOperators.sol","source_code":"// SPDX-License-Identifier: Unlicensed\n\n/**\n * @title ITraderOperators\n * @notice Interface for TraderOperators contract\n */\n\npragma solidity ^0.8.0;\n\nabstract contract ITraderOperators {\n function isTrader(address _account) external view virtual returns (bool);\n\n function addTrader(address _account) external virtual;\n\n function removeTrader(address _account) external virtual;\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[],"name":"InitializableContractAlreadyInitialized","type":"error"},{"inputs":[],"name":"InitializableContractIsInitializing","type":"error"},{"inputs":[],"name":"OperatorableCallerNotAdmin","type":"error"},{"inputs":[],"name":"OperatorableCallerNotAdminOrRelay","type":"error"},{"inputs":[],"name":"OperatorableCallerNotAdminOrSystem","type":"error"},{"inputs":[],"name":"OperatorableCallerNotMultisig","type":"error"},{"inputs":[],"name":"OperatorableCallerNotOperator","type":"error"},{"inputs":[],"name":"OperatorableCallerNotOperatorOrAdminOrRelay","type":"error"},{"inputs":[],"name":"OperatorableCallerNotOperatorOrRelay","type":"error"},{"inputs":[],"name":"OperatorableCallerNotOperatorOrSystem","type":"error"},{"inputs":[],"name":"OperatorableCallerNotOperatorOrSystemOrRelay","type":"error"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"}],"name":"OperatorableCallerNotOperatorsContract","type":"error"},{"inputs":[],"name":"OperatorableCallerNotRelay","type":"error"},{"inputs":[],"name":"OperatorableCallerNotSystem","type":"error"},{"inputs":[],"name":"OperatorableNewOperatorsZeroAddress","type":"error"},{"inputs":[],"name":"TokenFactoryCallerNotProxyAdmin","type":"error"},{"inputs":[],"name":"TokenFactoryEmptyBaseOperatorsAddress","type":"error"},{"inputs":[],"name":"TokenFactoryEmptyBlockerOperatorsAddress","type":"error"},{"inputs":[],"name":"TokenFactoryEmptyImplementationAddress","type":"error"},{"inputs":[],"name":"TokenFactoryEmptyProxyAdminAddress","type":"error"},{"inputs":[],"name":"TokenFactoryEmptyTraderOperatorsAddress","type":"error"},{"inputs":[],"name":"TokenFactoryEmptyWhitelistAddress","type":"error"},{"anonymous":false,"inputs":[],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"issuer","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"proxy","type":"address"}],"name":"NewTokenDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"operatorsAddress","type":"address"}],"name":"OperatorsContractChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"operatorsAddress","type":"address"}],"name":"OperatorsContractPending","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"blockerOperators","type":"address"}],"name":"UpdatedBlockerOperators","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"UpdatedImplementation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proxyAdmin","type":"address"}],"name":"UpdatedProxyAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"traderOperators","type":"address"}],"name":"UpdatedTraderOperators","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"whitelist","type":"address"}],"name":"UpdatedWhitelist","type":"event"},{"inputs":[],"name":"blockerOperators","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"confirmOperatorsContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getOperatorsContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOperatorsPending","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_baseOperators","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_baseOperators","type":"address"},{"internalType":"address","name":"_traderOperators","type":"address"},{"internalType":"address","name":"_blockerOperators","type":"address"},{"internalType":"address","name":"_whitelist","type":"address"},{"internalType":"address","name":"_implementation","type":"address"},{"internalType":"address","name":"_proxyAdmin","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isAdminOrSystem","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_contract","type":"address"}],"name":"isMultisig","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isOperatorOrSystem","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isRelay","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isSystem","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"bytes4","name":"category","type":"bytes4"},{"internalType":"string","name":"class","type":"string"},{"internalType":"address","name":"issuer","type":"address"},{"internalType":"string","name":"tokenURI","type":"string"},{"internalType":"address","name":"priceFeed","type":"address"}],"internalType":"struct Details.TokenDetails","name":"_details","type":"tuple"},{"internalType":"address","name":"_whitelist","type":"address"}],"name":"newToken","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"proxyAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_baseOperators","type":"address"}],"name":"setOperatorsContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"traderOperators","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_blockerOperators","type":"address"}],"name":"updateBlockerOperators","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_implementation","type":"address"}],"name":"updateImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_proxyAdmin","type":"address"}],"name":"updateProxyAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_traderOperators","type":"address"}],"name":"updateTraderOperators","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_whitelist","type":"address"}],"name":"updateWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whitelist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}],"is_changed_bytecode":true,"is_partially_verified":false,"package_name":null,"constructor_args":null}