{ "address": "0x52735D63bfAe96ddb1aD81C7356d938E8E5e2C19", "abi": [ { "inputs": [ { "components": [ { "internalType": "uint256", "name": "dailyLimit", "type": "uint256" }, { "internalType": "uint256", "name": "txLimit", "type": "uint256" }, { "internalType": "uint256", "name": "accountDailyLimit", "type": "uint256" }, { "internalType": "uint256", "name": "minAmount", "type": "uint256" }, { "internalType": "bool", "name": "onlyWhitelisted", "type": "bool" } ], "internalType": "struct IMessagePassingBridge.BridgeLimits", "name": "bridgeLimits", "type": "tuple" }, { "components": [ { "internalType": "uint256", "name": "lastTransferReset", "type": "uint256" }, { "internalType": "uint256", "name": "bridged24Hours", "type": "uint256" } ], "internalType": "struct IMessagePassingBridge.AccountLimit", "name": "accountDailyLimit", "type": "tuple" }, { "components": [ { "internalType": "uint256", "name": "lastTransferReset", "type": "uint256" }, { "internalType": "uint256", "name": "bridged24Hours", "type": "uint256" } ], "internalType": "struct IMessagePassingBridge.BridgeDailyLimit", "name": "bridgeDailyLimit", "type": "tuple" }, { "internalType": "contract INameService", "name": "nameService", "type": "INameService" }, { "internalType": "bool", "name": "isClosed", "type": "bool" }, { "internalType": "address", "name": "from", "type": "address" }, { "internalType": "uint256", "name": "amount", "type": "uint256" } ], "name": "canBridge", "outputs": [ { "internalType": "bool", "name": "isWithinLimit", "type": "bool" }, { "internalType": "string", "name": "error", "type": "string" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "amount", "type": "uint256" }, { "internalType": "uint8", "name": "decimals", "type": "uint8" } ], "name": "normalizeFrom18ToTokenDecimals", "outputs": [ { "internalType": "uint256", "name": "normalized", "type": "uint256" } ], "stateMutability": "pure", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "amount", "type": "uint256" }, { "internalType": "uint8", "name": "decimals", "type": "uint8" } ], "name": "normalizeFromTokenTo18Decimals", "outputs": [ { "internalType": "uint256", "name": "normalized", "type": "uint256" } ], "stateMutability": "pure", "type": "function" } ], "args": [], "numDeployments": 1, "solcInputHash": "8d676c286e4904800dec700bc7f8e761", "metadata": "{\"compiler\":{\"version\":\"0.8.10+commit.fc410830\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"dailyLimit\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"txLimit\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"accountDailyLimit\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minAmount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"onlyWhitelisted\",\"type\":\"bool\"}],\"internalType\":\"struct IMessagePassingBridge.BridgeLimits\",\"name\":\"bridgeLimits\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"lastTransferReset\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"bridged24Hours\",\"type\":\"uint256\"}],\"internalType\":\"struct IMessagePassingBridge.AccountLimit\",\"name\":\"accountDailyLimit\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"lastTransferReset\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"bridged24Hours\",\"type\":\"uint256\"}],\"internalType\":\"struct IMessagePassingBridge.BridgeDailyLimit\",\"name\":\"bridgeDailyLimit\",\"type\":\"tuple\"},{\"internalType\":\"contract INameService\",\"name\":\"nameService\",\"type\":\"INameService\"},{\"internalType\":\"bool\",\"name\":\"isClosed\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"canBridge\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isWithinLimit\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"}],\"name\":\"normalizeFrom18ToTokenDecimals\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"normalized\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"}],\"name\":\"normalizeFromTokenTo18Decimals\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"normalized\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"canBridge(IMessagePassingBridge.BridgeLimits,IMessagePassingBridge.AccountLimit,IMessagePassingBridge.BridgeDailyLimit,INameService,bool,address,uint256)\":{\"details\":\"Function for checking if a bridge is possible\",\"params\":{\"amount\":\"The amount to bridge\",\"from\":\"The address of the sender\"},\"returns\":{\"error\":\"The error message, if any\",\"isWithinLimit\":\"Whether the bridge is within the limit\"}},\"normalizeFrom18ToTokenDecimals(uint256,uint8)\":{\"details\":\"Function for normalizing token amounts from 18 decimals\",\"params\":{\"amount\":\"The amount to normalize\"},\"returns\":{\"normalized\":\"amount\"}},\"normalizeFromTokenTo18Decimals(uint256,uint8)\":{\"details\":\"Function for normalizing token amounts to 18 decimals\",\"params\":{\"amount\":\"The amount to normalize\"},\"returns\":{\"normalized\":\"amount\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/messagePassingBridge/BridgeHelperLibrary.sol\":\"BridgeHelperLibrary\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":0},\"remappings\":[]},\"sources\":{\"@gooddollar/goodprotocol/contracts/DAOStackInterfaces.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\ninterface Avatar {\\n\\tfunction nativeToken() external view returns (address);\\n\\n\\tfunction nativeReputation() external view returns (address);\\n\\n\\tfunction owner() external view returns (address);\\n}\\n\\ninterface Controller {\\n\\tevent RegisterScheme(address indexed _sender, address indexed _scheme);\\n\\tevent UnregisterScheme(address indexed _sender, address indexed _scheme);\\n\\n\\tfunction genericCall(\\n\\t\\taddress _contract,\\n\\t\\tbytes calldata _data,\\n\\t\\taddress _avatar,\\n\\t\\tuint256 _value\\n\\t) external returns (bool, bytes memory);\\n\\n\\tfunction avatar() external view returns (address);\\n\\n\\tfunction unregisterScheme(address _scheme, address _avatar)\\n\\t\\texternal\\n\\t\\treturns (bool);\\n\\n\\tfunction unregisterSelf(address _avatar) external returns (bool);\\n\\n\\tfunction registerScheme(\\n\\t\\taddress _scheme,\\n\\t\\tbytes32 _paramsHash,\\n\\t\\tbytes4 _permissions,\\n\\t\\taddress _avatar\\n\\t) external returns (bool);\\n\\n\\tfunction isSchemeRegistered(address _scheme, address _avatar)\\n\\t\\texternal\\n\\t\\tview\\n\\t\\treturns (bool);\\n\\n\\tfunction getSchemePermissions(address _scheme, address _avatar)\\n\\t\\texternal\\n\\t\\tview\\n\\t\\treturns (bytes4);\\n\\n\\tfunction addGlobalConstraint(\\n\\t\\taddress _constraint,\\n\\t\\tbytes32 _paramHash,\\n\\t\\taddress _avatar\\n\\t) external returns (bool);\\n\\n\\tfunction mintTokens(\\n\\t\\tuint256 _amount,\\n\\t\\taddress _beneficiary,\\n\\t\\taddress _avatar\\n\\t) external returns (bool);\\n\\n\\tfunction externalTokenTransfer(\\n\\t\\taddress _token,\\n\\t\\taddress _recipient,\\n\\t\\tuint256 _amount,\\n\\t\\taddress _avatar\\n\\t) external returns (bool);\\n\\n\\tfunction sendEther(\\n\\t\\tuint256 _amountInWei,\\n\\t\\taddress payable _to,\\n\\t\\taddress _avatar\\n\\t) external returns (bool);\\n}\\n\\ninterface GlobalConstraintInterface {\\n\\tenum CallPhase {\\n\\t\\tPre,\\n\\t\\tPost,\\n\\t\\tPreAndPost\\n\\t}\\n\\n\\tfunction pre(\\n\\t\\taddress _scheme,\\n\\t\\tbytes32 _params,\\n\\t\\tbytes32 _method\\n\\t) external returns (bool);\\n\\n\\t/**\\n\\t * @dev when return if this globalConstraints is pre, post or both.\\n\\t * @return CallPhase enum indication Pre, Post or PreAndPost.\\n\\t */\\n\\tfunction when() external returns (CallPhase);\\n}\\n\\ninterface ReputationInterface {\\n\\tfunction balanceOf(address _user) external view returns (uint256);\\n\\n\\tfunction balanceOfAt(address _user, uint256 _blockNumber)\\n\\t\\texternal\\n\\t\\tview\\n\\t\\treturns (uint256);\\n\\n\\tfunction getVotes(address _user) external view returns (uint256);\\n\\n\\tfunction getVotesAt(\\n\\t\\taddress _user,\\n\\t\\tbool _global,\\n\\t\\tuint256 _blockNumber\\n\\t) external view returns (uint256);\\n\\n\\tfunction totalSupply() external view returns (uint256);\\n\\n\\tfunction totalSupplyAt(uint256 _blockNumber)\\n\\t\\texternal\\n\\t\\tview\\n\\t\\treturns (uint256);\\n\\n\\tfunction delegateOf(address _user) external returns (address);\\n}\\n\\ninterface SchemeRegistrar {\\n\\tfunction proposeScheme(\\n\\t\\tAvatar _avatar,\\n\\t\\taddress _scheme,\\n\\t\\tbytes32 _parametersHash,\\n\\t\\tbytes4 _permissions,\\n\\t\\tstring memory _descriptionHash\\n\\t) external returns (bytes32);\\n\\n\\tevent NewSchemeProposal(\\n\\t\\taddress indexed _avatar,\\n\\t\\tbytes32 indexed _proposalId,\\n\\t\\taddress indexed _intVoteInterface,\\n\\t\\taddress _scheme,\\n\\t\\tbytes32 _parametersHash,\\n\\t\\tbytes4 _permissions,\\n\\t\\tstring _descriptionHash\\n\\t);\\n}\\n\\ninterface IntVoteInterface {\\n\\tevent NewProposal(\\n\\t\\tbytes32 indexed _proposalId,\\n\\t\\taddress indexed _organization,\\n\\t\\tuint256 _numOfChoices,\\n\\t\\taddress _proposer,\\n\\t\\tbytes32 _paramsHash\\n\\t);\\n\\n\\tevent ExecuteProposal(\\n\\t\\tbytes32 indexed _proposalId,\\n\\t\\taddress indexed _organization,\\n\\t\\tuint256 _decision,\\n\\t\\tuint256 _totalReputation\\n\\t);\\n\\n\\tevent VoteProposal(\\n\\t\\tbytes32 indexed _proposalId,\\n\\t\\taddress indexed _organization,\\n\\t\\taddress indexed _voter,\\n\\t\\tuint256 _vote,\\n\\t\\tuint256 _reputation\\n\\t);\\n\\n\\tevent CancelProposal(\\n\\t\\tbytes32 indexed _proposalId,\\n\\t\\taddress indexed _organization\\n\\t);\\n\\tevent CancelVoting(\\n\\t\\tbytes32 indexed _proposalId,\\n\\t\\taddress indexed _organization,\\n\\t\\taddress indexed _voter\\n\\t);\\n\\n\\t/**\\n\\t * @dev register a new proposal with the given parameters. Every proposal has a unique ID which is being\\n\\t * generated by calculating keccak256 of a incremented counter.\\n\\t * @param _numOfChoices number of voting choices\\n\\t * @param _proposalParameters defines the parameters of the voting machine used for this proposal\\n\\t * @param _proposer address\\n\\t * @param _organization address - if this address is zero the msg.sender will be used as the organization address.\\n\\t * @return proposal's id.\\n\\t */\\n\\tfunction propose(\\n\\t\\tuint256 _numOfChoices,\\n\\t\\tbytes32 _proposalParameters,\\n\\t\\taddress _proposer,\\n\\t\\taddress _organization\\n\\t) external returns (bytes32);\\n\\n\\tfunction vote(\\n\\t\\tbytes32 _proposalId,\\n\\t\\tuint256 _vote,\\n\\t\\tuint256 _rep,\\n\\t\\taddress _voter\\n\\t) external returns (bool);\\n\\n\\tfunction cancelVote(bytes32 _proposalId) external;\\n\\n\\tfunction getNumberOfChoices(bytes32 _proposalId)\\n\\t\\texternal\\n\\t\\tview\\n\\t\\treturns (uint256);\\n\\n\\tfunction isVotable(bytes32 _proposalId) external view returns (bool);\\n\\n\\t/**\\n\\t * @dev voteStatus returns the reputation voted for a proposal for a specific voting choice.\\n\\t * @param _proposalId the ID of the proposal\\n\\t * @param _choice the index in the\\n\\t * @return voted reputation for the given choice\\n\\t */\\n\\tfunction voteStatus(bytes32 _proposalId, uint256 _choice)\\n\\t\\texternal\\n\\t\\tview\\n\\t\\treturns (uint256);\\n\\n\\t/**\\n\\t * @dev isAbstainAllow returns if the voting machine allow abstain (0)\\n\\t * @return bool true or false\\n\\t */\\n\\tfunction isAbstainAllow() external pure returns (bool);\\n\\n\\t/**\\n * @dev getAllowedRangeOfChoices returns the allowed range of choices for a voting machine.\\n * @return min - minimum number of choices\\n max - maximum number of choices\\n */\\n\\tfunction getAllowedRangeOfChoices()\\n\\t\\texternal\\n\\t\\tpure\\n\\t\\treturns (uint256 min, uint256 max);\\n}\\n\",\"keccak256\":\"0x34e247b3a991a0d5f8e975c81df91199074eeb9d4999fcaac89bdf7787527b19\",\"license\":\"MIT\"},\"@gooddollar/goodprotocol/contracts/Interfaces.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\nimport { DataTypes } from \\\"./utils/DataTypes.sol\\\";\\npragma solidity >=0.8.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface ERC20 {\\n\\tfunction balanceOf(address addr) external view returns (uint256);\\n\\n\\tfunction transfer(address to, uint256 amount) external returns (bool);\\n\\n\\tfunction approve(address spender, uint256 amount) external returns (bool);\\n\\n\\tfunction decimals() external view returns (uint8);\\n\\n\\tfunction mint(address to, uint256 mintAmount) external returns (uint256);\\n\\n\\tfunction burn(uint256 amount) external;\\n\\n\\tfunction totalSupply() external view returns (uint256);\\n\\n\\tfunction allowance(\\n\\t\\taddress owner,\\n\\t\\taddress spender\\n\\t) external view returns (uint256);\\n\\n\\tfunction transferFrom(\\n\\t\\taddress sender,\\n\\t\\taddress recipient,\\n\\t\\tuint256 amount\\n\\t) external returns (bool);\\n\\n\\tfunction name() external view returns (string memory);\\n\\n\\tfunction symbol() external view returns (string memory);\\n\\n\\tevent Transfer(address indexed from, address indexed to, uint256 amount);\\n\\tevent Transfer(\\n\\t\\taddress indexed from,\\n\\t\\taddress indexed to,\\n\\t\\tuint256 amount,\\n\\t\\tbytes data\\n\\t);\\n}\\n\\ninterface cERC20 is ERC20 {\\n\\tfunction mint(uint256 mintAmount) external returns (uint256);\\n\\n\\tfunction redeemUnderlying(uint256 mintAmount) external returns (uint256);\\n\\n\\tfunction redeem(uint256 mintAmount) external returns (uint256);\\n\\n\\tfunction exchangeRateCurrent() external returns (uint256);\\n\\n\\tfunction exchangeRateStored() external view returns (uint256);\\n\\n\\tfunction underlying() external returns (address);\\n}\\n\\ninterface IGoodDollar is ERC20 {\\n\\t// view functions\\n\\tfunction feeRecipient() external view returns (address);\\n\\n\\tfunction getFees(\\n\\t\\tuint256 value,\\n\\t\\taddress sender,\\n\\t\\taddress recipient\\n\\t) external view returns (uint256 fee, bool senderPays);\\n\\n\\tfunction cap() external view returns (uint256);\\n\\n\\tfunction isPauser(address _pauser) external view returns (bool);\\n\\n\\tfunction getFees(uint256 value) external view returns (uint256, bool);\\n\\n\\tfunction isMinter(address minter) external view returns (bool);\\n\\n\\tfunction formula() external view returns (address);\\n\\n\\tfunction identity() external view returns (address);\\n\\n\\tfunction owner() external view returns (address);\\n\\n\\t// state changing functions\\n\\tfunction setFeeRecipient(address _feeRecipient) external;\\n\\n\\tfunction setFormula(address _formula) external;\\n\\n\\tfunction transferOwnership(address _owner) external;\\n\\n\\tfunction addPauser(address _pauser) external;\\n\\n\\tfunction pause() external;\\n\\n\\tfunction unpause() external;\\n\\n\\tfunction burn(uint256 amount) external;\\n\\n\\tfunction burnFrom(address account, uint256 amount) external;\\n\\n\\tfunction renounceMinter() external;\\n\\n\\tfunction addMinter(address minter) external;\\n\\n\\tfunction transferAndCall(\\n\\t\\taddress to,\\n\\t\\tuint256 value,\\n\\t\\tbytes calldata data\\n\\t) external returns (bool);\\n\\n\\tfunction setIdentity(address identity) external;\\n}\\n\\ninterface IERC2917 is ERC20 {\\n\\t/// @dev This emit when interests amount per block is changed by the owner of the contract.\\n\\t/// It emits with the old interests amount and the new interests amount.\\n\\tevent InterestRatePerBlockChanged(uint256 oldValue, uint256 newValue);\\n\\n\\t/// @dev This emit when a users' productivity has changed\\n\\t/// It emits with the user's address and the the value after the change.\\n\\tevent ProductivityIncreased(address indexed user, uint256 value);\\n\\n\\t/// @dev This emit when a users' productivity has changed\\n\\t/// It emits with the user's address and the the value after the change.\\n\\tevent ProductivityDecreased(address indexed user, uint256 value);\\n\\n\\t/// @dev Return the current contract's interests rate per block.\\n\\t/// @return The amount of interests currently producing per each block.\\n\\tfunction interestsPerBlock() external view returns (uint256);\\n\\n\\t/// @notice Change the current contract's interests rate.\\n\\t/// @dev Note the best practice will be restrict the gross product provider's contract address to call this.\\n\\t/// @return The true/fase to notice that the value has successfully changed or not, when it succeed, it will emite the InterestRatePerBlockChanged event.\\n\\tfunction changeInterestRatePerBlock(uint256 value) external returns (bool);\\n\\n\\t/// @notice It will get the productivity of given user.\\n\\t/// @dev it will return 0 if user has no productivity proved in the contract.\\n\\t/// @return user's productivity and overall productivity.\\n\\tfunction getProductivity(\\n\\t\\taddress user\\n\\t) external view returns (uint256, uint256);\\n\\n\\t/// @notice increase a user's productivity.\\n\\t/// @dev Note the best practice will be restrict the callee to prove of productivity's contract address.\\n\\t/// @return true to confirm that the productivity added success.\\n\\tfunction increaseProductivity(\\n\\t\\taddress user,\\n\\t\\tuint256 value\\n\\t) external returns (bool);\\n\\n\\t/// @notice decrease a user's productivity.\\n\\t/// @dev Note the best practice will be restrict the callee to prove of productivity's contract address.\\n\\t/// @return true to confirm that the productivity removed success.\\n\\tfunction decreaseProductivity(\\n\\t\\taddress user,\\n\\t\\tuint256 value\\n\\t) external returns (bool);\\n\\n\\t/// @notice take() will return the interests that callee will get at current block height.\\n\\t/// @dev it will always calculated by block.number, so it will change when block height changes.\\n\\t/// @return amount of the interests that user are able to mint() at current block height.\\n\\tfunction take() external view returns (uint256);\\n\\n\\t/// @notice similar to take(), but with the block height joined to calculate return.\\n\\t/// @dev for instance, it returns (_amount, _block), which means at block height _block, the callee has accumulated _amount of interests.\\n\\t/// @return amount of interests and the block height.\\n\\tfunction takeWithBlock() external view returns (uint256, uint256);\\n\\n\\t/// @notice mint the avaiable interests to callee.\\n\\t/// @dev once it mint, the amount of interests will transfer to callee's address.\\n\\t/// @return the amount of interests minted.\\n\\tfunction mint() external returns (uint256);\\n}\\n\\ninterface Staking {\\n\\tstruct Staker {\\n\\t\\t// The staked DAI amount\\n\\t\\tuint256 stakedDAI;\\n\\t\\t// The latest block number which the\\n\\t\\t// staker has staked tokens\\n\\t\\tuint256 lastStake;\\n\\t}\\n\\n\\tfunction stakeDAI(uint256 amount) external;\\n\\n\\tfunction withdrawStake() external;\\n\\n\\tfunction stakers(address staker) external view returns (Staker memory);\\n}\\n\\ninterface Uniswap {\\n\\tfunction swapExactETHForTokens(\\n\\t\\tuint256 amountOutMin,\\n\\t\\taddress[] calldata path,\\n\\t\\taddress to,\\n\\t\\tuint256 deadline\\n\\t) external payable returns (uint256[] memory amounts);\\n\\n\\tfunction swapExactTokensForETH(\\n\\t\\tuint256 amountIn,\\n\\t\\tuint256 amountOutMin,\\n\\t\\taddress[] calldata path,\\n\\t\\taddress to,\\n\\t\\tuint256 deadline\\n\\t) external returns (uint256[] memory amounts);\\n\\n\\tfunction swapExactTokensForTokens(\\n\\t\\tuint256 amountIn,\\n\\t\\tuint256 amountOutMin,\\n\\t\\taddress[] calldata path,\\n\\t\\taddress to,\\n\\t\\tuint256 deadline\\n\\t) external returns (uint256[] memory amounts);\\n\\n\\tfunction WETH() external pure returns (address);\\n\\n\\tfunction factory() external pure returns (address);\\n\\n\\tfunction quote(\\n\\t\\tuint256 amountA,\\n\\t\\tuint256 reserveA,\\n\\t\\tuint256 reserveB\\n\\t) external pure returns (uint256 amountB);\\n\\n\\tfunction getAmountIn(\\n\\t\\tuint256 amountOut,\\n\\t\\tuint256 reserveIn,\\n\\t\\tuint256 reserveOut\\n\\t) external pure returns (uint256 amountIn);\\n\\n\\tfunction getAmountOut(\\n\\t\\tuint256 amountI,\\n\\t\\tuint256 reserveIn,\\n\\t\\tuint256 reserveOut\\n\\t) external pure returns (uint256 amountOut);\\n\\n\\tfunction getAmountsOut(\\n\\t\\tuint256 amountIn,\\n\\t\\taddress[] memory path\\n\\t) external pure returns (uint256[] memory amounts);\\n}\\n\\ninterface UniswapFactory {\\n\\tfunction getPair(\\n\\t\\taddress tokenA,\\n\\t\\taddress tokenB\\n\\t) external view returns (address);\\n}\\n\\ninterface UniswapPair {\\n\\tfunction getReserves()\\n\\t\\texternal\\n\\t\\tview\\n\\t\\treturns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\\n\\n\\tfunction kLast() external view returns (uint256);\\n\\n\\tfunction token0() external view returns (address);\\n\\n\\tfunction token1() external view returns (address);\\n\\n\\tfunction totalSupply() external view returns (uint256);\\n\\n\\tfunction balanceOf(address owner) external view returns (uint256);\\n}\\n\\ninterface Reserve {\\n\\tfunction buy(\\n\\t\\taddress _buyWith,\\n\\t\\tuint256 _tokenAmount,\\n\\t\\tuint256 _minReturn\\n\\t) external returns (uint256);\\n}\\n\\ninterface IIdentity {\\n\\tfunction isWhitelisted(address user) external view returns (bool);\\n\\n\\tfunction addWhitelistedWithDID(address account, string memory did) external;\\n\\n\\tfunction removeWhitelisted(address account) external;\\n\\n\\tfunction addBlacklisted(address account) external;\\n\\n\\tfunction removeBlacklisted(address account) external;\\n\\n\\tfunction isBlacklisted(address user) external view returns (bool);\\n\\n\\tfunction addIdentityAdmin(address account) external returns (bool);\\n\\n\\tfunction setAvatar(address _avatar) external;\\n\\n\\tfunction isIdentityAdmin(address account) external view returns (bool);\\n\\n\\tfunction owner() external view returns (address);\\n\\n\\tfunction removeContract(address account) external;\\n\\n\\tfunction isDAOContract(address account) external view returns (bool);\\n\\n\\tfunction addrToDID(address account) external view returns (string memory);\\n\\n\\tfunction didHashToAddress(bytes32 hash) external view returns (address);\\n\\n\\tfunction lastAuthenticated(address account) external view returns (uint256);\\n\\n\\tevent WhitelistedAdded(address user);\\n}\\n\\ninterface IIdentityV2 is IIdentity {\\n\\tfunction addWhitelistedWithDIDAndChain(\\n\\t\\taddress account,\\n\\t\\tstring memory did,\\n\\t\\tuint256 orgChainId,\\n\\t\\tuint256 dateAuthenticated\\n\\t) external;\\n\\n\\tfunction getWhitelistedRoot(\\n\\t\\taddress account\\n\\t) external view returns (address root);\\n}\\n\\ninterface IUBIScheme {\\n\\tfunction currentDay() external view returns (uint256);\\n\\n\\tfunction periodStart() external view returns (uint256);\\n\\n\\tfunction hasClaimed(address claimer) external view returns (bool);\\n}\\n\\ninterface IFirstClaimPool {\\n\\tfunction awardUser(address user) external returns (uint256);\\n\\n\\tfunction claimAmount() external view returns (uint256);\\n\\n\\tfunction end() external;\\n}\\n\\ninterface ProxyAdmin {\\n\\tfunction getProxyImplementation(\\n\\t\\taddress proxy\\n\\t) external view returns (address);\\n\\n\\tfunction getProxyAdmin(address proxy) external view returns (address);\\n\\n\\tfunction upgrade(address proxy, address implementation) external;\\n\\n\\tfunction owner() external view returns (address);\\n\\n\\tfunction transferOwnership(address newOwner) external;\\n\\n\\tfunction upgradeAndCall(\\n\\t\\taddress proxy,\\n\\t\\taddress implementation,\\n\\t\\tbytes memory data\\n\\t) external;\\n}\\n\\n/**\\n * @dev Interface for chainlink oracles to obtain price datas\\n */\\ninterface AggregatorV3Interface {\\n\\tfunction decimals() external view returns (uint8);\\n\\n\\tfunction description() external view returns (string memory);\\n\\n\\tfunction version() external view returns (uint256);\\n\\n\\t// getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n\\t// if they do not have data to report, instead of returning unset values\\n\\t// which could be misinterpreted as actual reported values.\\n\\tfunction getRoundData(\\n\\t\\tuint80 _roundId\\n\\t)\\n\\t\\texternal\\n\\t\\tview\\n\\t\\treturns (\\n\\t\\t\\tuint80 roundId,\\n\\t\\t\\tint256 answer,\\n\\t\\t\\tuint256 startedAt,\\n\\t\\t\\tuint256 updatedAt,\\n\\t\\t\\tuint80 answeredInRound\\n\\t\\t);\\n\\n\\tfunction latestAnswer() external view returns (int256);\\n}\\n\\n/**\\n\\t@dev interface for AAVE lending Pool\\n */\\ninterface ILendingPool {\\n\\t/**\\n\\t * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n\\t * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n\\t * @param asset The address of the underlying asset to deposit\\n\\t * @param amount The amount to be deposited\\n\\t * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n\\t * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n\\t * is a different wallet\\n\\t * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n\\t * 0 if the action is executed directly by the user, without any middle-man\\n\\t **/\\n\\tfunction deposit(\\n\\t\\taddress asset,\\n\\t\\tuint256 amount,\\n\\t\\taddress onBehalfOf,\\n\\t\\tuint16 referralCode\\n\\t) external;\\n\\n\\t/**\\n\\t * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n\\t * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n\\t * @param asset The address of the underlying asset to withdraw\\n\\t * @param amount The underlying amount to be withdrawn\\n\\t * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n\\t * @param to Address that will receive the underlying, same as msg.sender if the user\\n\\t * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n\\t * different wallet\\n\\t * @return The final amount withdrawn\\n\\t **/\\n\\tfunction withdraw(\\n\\t\\taddress asset,\\n\\t\\tuint256 amount,\\n\\t\\taddress to\\n\\t) external returns (uint256);\\n\\n\\t/**\\n\\t * @dev Returns the state and configuration of the reserve\\n\\t * @param asset The address of the underlying asset of the reserve\\n\\t * @return The state of the reserve\\n\\t **/\\n\\tfunction getReserveData(\\n\\t\\taddress asset\\n\\t) external view returns (DataTypes.ReserveData memory);\\n}\\n\\ninterface IDonationStaking {\\n\\tfunction stakeDonations() external payable;\\n}\\n\\ninterface INameService {\\n\\tfunction getAddress(string memory _name) external view returns (address);\\n}\\n\\ninterface IAaveIncentivesController {\\n\\t/**\\n\\t * @dev Claims reward for an user, on all the assets of the lending pool, accumulating the pending rewards\\n\\t * @param amount Amount of rewards to claim\\n\\t * @param to Address that will be receiving the rewards\\n\\t * @return Rewards claimed\\n\\t **/\\n\\tfunction claimRewards(\\n\\t\\taddress[] calldata assets,\\n\\t\\tuint256 amount,\\n\\t\\taddress to\\n\\t) external returns (uint256);\\n\\n\\t/**\\n\\t * @dev Returns the total of rewards of an user, already accrued + not yet accrued\\n\\t * @param user The address of the user\\n\\t * @return The rewards\\n\\t **/\\n\\tfunction getRewardsBalance(\\n\\t\\taddress[] calldata assets,\\n\\t\\taddress user\\n\\t) external view returns (uint256);\\n}\\n\\ninterface IGoodStaking {\\n\\tfunction collectUBIInterest(\\n\\t\\taddress recipient\\n\\t) external returns (uint256, uint256, uint256);\\n\\n\\tfunction iToken() external view returns (address);\\n\\n\\tfunction currentGains(\\n\\t\\tbool _returnTokenBalanceInUSD,\\n\\t\\tbool _returnTokenGainsInUSD\\n\\t) external view returns (uint256, uint256, uint256, uint256, uint256);\\n\\n\\tfunction getRewardEarned(address user) external view returns (uint256);\\n\\n\\tfunction getGasCostForInterestTransfer() external view returns (uint256);\\n\\n\\tfunction rewardsMinted(\\n\\t\\taddress user,\\n\\t\\tuint256 rewardsPerBlock,\\n\\t\\tuint256 blockStart,\\n\\t\\tuint256 blockEnd\\n\\t) external returns (uint256);\\n}\\n\\ninterface IHasRouter {\\n\\tfunction getRouter() external view returns (Uniswap);\\n}\\n\\ninterface IAdminWallet {\\n\\tfunction addAdmins(address payable[] memory _admins) external;\\n\\n\\tfunction removeAdmins(address[] memory _admins) external;\\n\\n\\tfunction owner() external view returns (address);\\n\\n\\tfunction transferOwnership(address _owner) external;\\n}\\n\\ninterface IMultichainRouter {\\n\\t// Swaps `amount` `token` from this chain to `toChainID` chain with recipient `to`\\n\\tfunction anySwapOut(\\n\\t\\taddress token,\\n\\t\\taddress to,\\n\\t\\tuint256 amount,\\n\\t\\tuint256 toChainID\\n\\t) external;\\n\\n\\t// Swaps `amount` `token` from this chain to `toChainID` chain with recipient `to`\\n\\tfunction anySwapOutUnderlying(\\n\\t\\taddress token,\\n\\t\\taddress to,\\n\\t\\tuint256 amount,\\n\\t\\tuint256 toChainID\\n\\t) external;\\n}\\n\",\"keccak256\":\"0x57739a30eb70aac5df7ca4009a557931ccf13a4b8275bfb33dd45220aab15412\",\"license\":\"MIT\"},\"@gooddollar/goodprotocol/contracts/utils/DAOContract.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\nimport \\\"../DAOStackInterfaces.sol\\\";\\nimport \\\"../Interfaces.sol\\\";\\n\\n/**\\n@title Simple contract that keeps DAO contracts registery\\n*/\\n\\ncontract DAOContract {\\n\\tController public dao;\\n\\n\\taddress public avatar;\\n\\n\\tINameService public nameService;\\n\\n\\tfunction _onlyAvatar() internal view {\\n\\t\\trequire(\\n\\t\\t\\taddress(dao.avatar()) == msg.sender,\\n\\t\\t\\t\\\"only avatar can call this method\\\"\\n\\t\\t);\\n\\t}\\n\\n\\tfunction setDAO(INameService _ns) internal {\\n\\t\\tnameService = _ns;\\n\\t\\tupdateAvatar();\\n\\t}\\n\\n\\tfunction updateAvatar() public {\\n\\t\\tdao = Controller(nameService.getAddress(\\\"CONTROLLER\\\"));\\n\\t\\tavatar = dao.avatar();\\n\\t}\\n\\n\\tfunction nativeToken() public view returns (IGoodDollar) {\\n\\t\\treturn IGoodDollar(nameService.getAddress(\\\"GOODDOLLAR\\\"));\\n\\t}\\n\\n\\tuint256[50] private gap;\\n}\\n\",\"keccak256\":\"0x82eb2588243e03c753d5e999514c50c01bb08aae30e4b025980dc4cb5b085b7b\",\"license\":\"MIT\"},\"@gooddollar/goodprotocol/contracts/utils/DAOUpgradeableContract.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\n\\nimport \\\"./DAOContract.sol\\\";\\n\\n/**\\n@title Simple contract that adds upgradability to DAOContract\\n*/\\n\\ncontract DAOUpgradeableContract is Initializable, UUPSUpgradeable, DAOContract {\\n\\tfunction _authorizeUpgrade(address) internal virtual override {\\n\\t\\t_onlyAvatar();\\n\\t}\\n}\\n\",\"keccak256\":\"0xecb2c36f87418eb33eb3877e0fab5711c1a9c2d6ceabfb0edeb2ad2b172ecdc2\",\"license\":\"MIT\"},\"@gooddollar/goodprotocol/contracts/utils/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.0;\\n\\nlibrary DataTypes {\\n\\t// refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n\\tstruct ReserveData {\\n\\t\\t//stores the reserve configuration\\n\\t\\tReserveConfigurationMap configuration;\\n\\t\\t//the liquidity index. Expressed in ray\\n\\t\\tuint128 liquidityIndex;\\n\\t\\t//variable borrow index. Expressed in ray\\n\\t\\tuint128 variableBorrowIndex;\\n\\t\\t//the current supply rate. Expressed in ray\\n\\t\\tuint128 currentLiquidityRate;\\n\\t\\t//the current variable borrow rate. Expressed in ray\\n\\t\\tuint128 currentVariableBorrowRate;\\n\\t\\t//the current stable borrow rate. Expressed in ray\\n\\t\\tuint128 currentStableBorrowRate;\\n\\t\\tuint40 lastUpdateTimestamp;\\n\\t\\t//tokens addresses\\n\\t\\taddress aTokenAddress;\\n\\t\\taddress stableDebtTokenAddress;\\n\\t\\taddress variableDebtTokenAddress;\\n\\t\\t//address of the interest rate strategy\\n\\t\\taddress interestRateStrategyAddress;\\n\\t\\t//the id of the reserve. Represents the position in the list of the active reserves\\n\\t\\tuint8 id;\\n\\t}\\n\\n\\tstruct ReserveConfigurationMap {\\n\\t\\t//bit 0-15: LTV\\n\\t\\t//bit 16-31: Liq. threshold\\n\\t\\t//bit 32-47: Liq. bonus\\n\\t\\t//bit 48-55: Decimals\\n\\t\\t//bit 56: Reserve is active\\n\\t\\t//bit 57: reserve is frozen\\n\\t\\t//bit 58: borrowing is enabled\\n\\t\\t//bit 59: stable rate borrowing enabled\\n\\t\\t//bit 60-63: reserved\\n\\t\\t//bit 64-79: reserve factor\\n\\t\\tuint256 data;\\n\\t}\\n\\tenum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xbc0c2512438c5b8d92e7ecd3c4d0848edf24ef0bacaf51744048173f60a2114c\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol\":{\"content\":\"// 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 IERC1822ProxiableUpgradeable {\\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\",\"keccak256\":\"0x77c89f893e403efc6929ba842b7ccf6534d4ffe03afe31670b4a528c0ad78c0f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeaconUpgradeable.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/StorageSlotUpgradeable.sol\\\";\\nimport \\\"../utils/Initializable.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 *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\\n function __ERC1967Upgrade_init() internal onlyInitializing {\\n }\\n\\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\\n }\\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 Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlotUpgradeable.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(AddressUpgradeable.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlotUpgradeable.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(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n _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(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) 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 (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822ProxiableUpgradeable(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 Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlotUpgradeable.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 StorageSlotUpgradeable.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 Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlotUpgradeable.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(AddressUpgradeable.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlotUpgradeable.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(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\\n }\\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(address target, bytes memory data) private returns (bytes memory) {\\n require(AddressUpgradeable.isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return AddressUpgradeable.verifyCallResult(success, returndata, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x315887e846f1e5f8d8fa535a229d318bb9290aaa69485117f1ee8a9a6b3be823\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol\":{\"content\":\"// 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 IBeaconUpgradeable {\\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\",\"keccak256\":\"0x24b86ac8c005b8c654fbf6ac34a5a4f61580d7273541e83e013e89d66fbf0908\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\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 */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 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(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n * constructor.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: setting the version to 255 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\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 require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n\\n /**\\n * @dev Internal function that returns the initialized version. Returns `_initialized`\\n */\\n function _getInitializedVersion() internal view returns (uint8) {\\n return _initialized;\\n }\\n\\n /**\\n * @dev Internal function that returns the initialized version. Returns `_initializing`\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _initializing;\\n }\\n}\\n\",\"keccak256\":\"0xe798cadb41e2da274913e4b3183a80f50fb057a42238fe8467e077268100ec27\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../ERC1967/ERC1967UpgradeUpgradeable.sol\\\";\\nimport \\\"./Initializable.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * _Available since v4.1._\\n */\\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\\n function __UUPSUpgradeable_init() internal onlyInitializing {\\n }\\n\\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\\n }\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\\n address private immutable __self = address(this);\\n\\n /**\\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n * fail.\\n */\\n modifier onlyProxy() {\\n require(address(this) != __self, \\\"Function must be called through delegatecall\\\");\\n require(_getImplementation() == __self, \\\"Function must be called through active proxy\\\");\\n _;\\n }\\n\\n /**\\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n * callable on the implementing contract but not through proxies.\\n */\\n modifier notDelegated() {\\n require(address(this) == __self, \\\"UUPSUpgradeable: must not be called through delegatecall\\\");\\n _;\\n }\\n\\n /**\\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\\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. This is guaranteed by the `notDelegated` modifier.\\n */\\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\\n return _IMPLEMENTATION_SLOT;\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeTo(address newImplementation) external virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n * encoded in `data`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, data, true);\\n }\\n\\n /**\\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n * {upgradeTo} and {upgradeToAndCall}.\\n *\\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n *\\n * ```solidity\\n * function _authorizeUpgrade(address) internal override onlyOwner {}\\n * ```\\n */\\n function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x7967d130887c4b40666cd88f8744691d4527039a1b2a38aa0de41481ef646778\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\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 *\\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://diligence.consensys.net/posts/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.5.11/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(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) 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 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\",\"keccak256\":\"0x2edcb41c121abc510932e8d83ff8b82cf9cdde35e7c297622f5c29ef0af25183\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\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 * ```\\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`, and `uint256`._\\n */\\nlibrary StorageSlotUpgradeable {\\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 /**\\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\",\"keccak256\":\"0x09864aea84f01e39313375b5610c73a3c1c68abbdc51e5ccdd25ff977fdadf9a\",\"license\":\"MIT\"},\"contracts/messagePassingBridge/BridgeHelperLibrary.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.0;\\nimport {INameService} from '@gooddollar/goodprotocol/contracts/utils/DAOUpgradeableContract.sol';\\nimport './IMessagePassingBridge.sol';\\n\\ninterface IIdentity {\\n function isWhitelisted(address) external view returns (bool);\\n}\\n\\nlibrary BridgeHelperLibrary {\\n /**\\n * @dev Function for normalizing token amounts to 18 decimals\\n * @param amount The amount to normalize\\n * @return normalized amount\\n */\\n function normalizeFromTokenTo18Decimals(uint256 amount, uint8 decimals) external pure returns (uint256 normalized) {\\n normalized = amount;\\n if (decimals < 18) {\\n uint256 diff = 18 - decimals;\\n normalized = amount * 10 ** diff;\\n } else if (decimals > 18) {\\n uint256 diff = decimals - 18;\\n normalized = amount / 10 ** diff;\\n }\\n }\\n\\n /**\\n * @dev Function for normalizing token amounts from 18 decimals\\n * @param amount The amount to normalize\\n * @return normalized amount\\n */\\n function normalizeFrom18ToTokenDecimals(uint256 amount, uint8 decimals) external pure returns (uint256 normalized) {\\n normalized = amount;\\n if (decimals < 18) {\\n uint256 diff = 18 - decimals;\\n normalized = amount / 10 ** diff;\\n } else if (decimals > 18) {\\n uint256 diff = decimals - 18;\\n normalized = amount * 10 ** diff;\\n }\\n }\\n\\n /**\\n * @dev Function for checking if a bridge is possible\\n * @param from The address of the sender\\n * @param amount The amount to bridge\\n * @return isWithinLimit Whether the bridge is within the limit\\n * @return error The error message, if any\\n */\\n function canBridge(\\n IMessagePassingBridge.BridgeLimits memory bridgeLimits,\\n IMessagePassingBridge.AccountLimit memory accountDailyLimit,\\n IMessagePassingBridge.BridgeDailyLimit memory bridgeDailyLimit,\\n INameService nameService,\\n bool isClosed,\\n address from,\\n uint256 amount\\n ) public view returns (bool isWithinLimit, string memory error) {\\n if (isClosed) return (false, 'closed');\\n\\n if (amount < bridgeLimits.minAmount) return (false, 'minAmount');\\n\\n uint256 account24hours = accountDailyLimit.bridged24Hours;\\n if (accountDailyLimit.lastTransferReset < block.timestamp - 1 days) {\\n account24hours = amount;\\n } else {\\n account24hours += amount;\\n }\\n\\n if (bridgeLimits.onlyWhitelisted && address(nameService) != address(0)) {\\n IIdentity id = IIdentity(nameService.getAddress('IDENTITY'));\\n if (address(id) != address(0))\\n if (id.isWhitelisted(from) == false) return (false, 'not whitelisted');\\n }\\n\\n if (account24hours > bridgeLimits.accountDailyLimit) return (false, 'accountDailyLimit');\\n\\n if (amount > bridgeLimits.txLimit) return (false, 'txLimit');\\n\\n if (bridgeDailyLimit.lastTransferReset < block.timestamp - 1 days) {\\n if (amount > bridgeLimits.dailyLimit) return (false, 'dailyLimit');\\n } else {\\n if (bridgeDailyLimit.bridged24Hours + amount > bridgeLimits.dailyLimit) return (false, 'dailyLimit');\\n }\\n\\n return (true, '');\\n }\\n}\\n\",\"keccak256\":\"0x813ebf4ef30b4d4e7ea0fa6cb9298ad513b1c2ae5b6b390896f986542b799eac\",\"license\":\"MIT\"},\"contracts/messagePassingBridge/IMessagePassingBridge.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.0;\\n\\ninterface ILayerZeroFeeEstimator {\\n function estimateSendFee(\\n uint16 _dstChainId,\\n address _fromAddress,\\n address _toAddress,\\n uint _normalizedAmount,\\n bool _useZro,\\n bytes memory _adapterParams\\n ) external view returns (uint nativeFee, uint zroFee);\\n}\\n\\ninterface IMessagePassingBridge {\\n enum BridgeService {\\n AXELAR,\\n LZ\\n }\\n\\n // A struct for storing account limits\\n struct AccountLimit {\\n uint256 lastTransferReset;\\n uint256 bridged24Hours;\\n }\\n\\n // A struct for storing bridge daily limits\\n struct BridgeDailyLimit {\\n uint256 lastTransferReset;\\n uint256 bridged24Hours;\\n }\\n\\n // A struct for storing bridge fees\\n struct BridgeFees {\\n uint256 minFee;\\n uint256 maxFee;\\n uint256 fee;\\n }\\n\\n // A struct for storing bridge limits\\n struct BridgeLimits {\\n uint256 dailyLimit;\\n uint256 txLimit;\\n uint256 accountDailyLimit;\\n uint256 minAmount;\\n bool onlyWhitelisted;\\n }\\n\\n function lzEndpoint_() external view returns (address);\\n\\n function TESTNET() external view returns (bool);\\n\\n function guardian() external view returns (address);\\n\\n function bridgeFees() external view returns (uint256 minFee, uint256 maxFee, uint256 fee);\\n\\n function bridgeLimits()\\n external\\n view\\n returns (\\n uint256 dailyLimit,\\n uint256 txLimit,\\n uint256 accountDailyLimit,\\n uint256 minAmount,\\n bool onlyWhitelisted\\n );\\n\\n function bridgeDailyLimit() external view returns (uint256 lastTransferReset, uint256 bridged24Hours);\\n\\n function feeRecipient() external view returns (address);\\n\\n function toLzChainId(uint256 chainId) external view returns (uint16 lzChainId);\\n\\n function setFeeRecipient(address recipient) external;\\n\\n function setBridgeLimits(BridgeLimits memory _limits) external;\\n\\n function setBridgeFees(BridgeFees memory _fees) external;\\n\\n function setDisabledBridges(bytes32[] memory bridgeKeys, bool[] memory disabled) external;\\n\\n function setFaucet(address _faucet) external;\\n\\n function setGuardian(address _guardian) external;\\n\\n function canBridge(address from, uint256 amount) external view returns (bool isWithinLimit, string memory error);\\n\\n function withdraw(address token, uint256 amount) external;\\n\\n function pauseBridge(bool isPaused) external;\\n\\n function bridgeTo(address target, uint256 targetChainId, uint256 amount, BridgeService bridge) external payable;\\n\\n function bridgeToWithLz(\\n address target,\\n uint256 targetChainId,\\n uint256 amount,\\n bytes calldata adapterParams\\n ) external payable;\\n\\n function bridgeToWithAxelar(\\n address target,\\n uint256 targetChainId,\\n uint256 amount,\\n address gasRefundAddress\\n ) external payable;\\n\\n function executedRequests(uint256 id) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xc178bba8f79f5d1602828b7f54e04091a5aaf82df0802efab6862ca94979e74b\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "kind": "dev", "methods": { "canBridge(IMessagePassingBridge.BridgeLimits,IMessagePassingBridge.AccountLimit,IMessagePassingBridge.BridgeDailyLimit,INameService,bool,address,uint256)": { "details": "Function for checking if a bridge is possible", "params": { "amount": "The amount to bridge", "from": "The address of the sender" }, "returns": { "error": "The error message, if any", "isWithinLimit": "Whether the bridge is within the limit" } }, "normalizeFrom18ToTokenDecimals(uint256,uint8)": { "details": "Function for normalizing token amounts from 18 decimals", "params": { "amount": "The amount to normalize" }, "returns": { "normalized": "amount" } }, "normalizeFromTokenTo18Decimals(uint256,uint8)": { "details": "Function for normalizing token amounts to 18 decimals", "params": { "amount": "The amount to normalize" }, "returns": { "normalized": "amount" } } }, "version": 1 }, "userdoc": { "kind": "user", "methods": {}, "version": 1 }, "storageLayout": { "storage": [], "types": null } }