def deposit_contract( DepositContract: ContractContainer, deposit_token_contract: Any, owner: Account, ) -> Any: deposit_contract = owner.deploy(DepositContract, deposit_token_contract) return deposit_contract
def executor_contract( ExecutorContract: ContractContainer, config_contract: Any, mock_batcher_contract: Any, owner: Account, ) -> Any: executor_contract = owner.deploy(ExecutorContract, config_contract, mock_batcher_contract) return executor_contract
def batcher_contract( BatcherContract: ContractContainer, config_contract: Any, fee_bank_contract: Any, owner: Account, ) -> Any: config_contract = owner.deploy(BatcherContract, config_contract, fee_bank_contract) return config_contract
def update_address_balances(): for address in ADDRESS_BALANCES: try: balance = Account(address).balance().to("ether") BALANCE.labels(NETWORK, address).set(balance) except ValueError as e: print(f"Error while balance of {address}: {e}") traceback.print_exc()
def executor_contract( ExecutorContract: ContractContainer, config_contract: Any, batcher_contract: Any, owner: Account, ) -> Any: # overrides executor_contract fixture in tests/conftest.py which uses mock_batcher_contract executor_contract = owner.deploy(ExecutorContract, config_contract, batcher_contract) return executor_contract
def keyper_slasher( KeyperSlasher: ContractContainer, config_contract: Any, executor_contract: Any, deposit_contract: Any, owner: Account, appeal_blocks: int, ) -> Any: keyper_slasher = owner.deploy( KeyperSlasher, appeal_blocks, config_contract, executor_contract, deposit_contract ) return keyper_slasher
def __init__(cls, alice: Account, ERC721: ContractContainer, xhibit: Contract): cls.alice = alice cls.xhibit = xhibit # create 10 mock ERC721 contracts for _ in range(10): instance = alice.deploy(ERC721) # create 10 xhibit NFTs as well xhibit.mint(alice, {"from": alice}) # create 10 NFTs in this contract instance for _ in range(10): instance._mint_for_testing(alice, {"from": alice})
def deploy_proxy_uninitialized(contractName, logicAbi, logic, proxyAdmin, deployer: Account): abi = artifacts.open_zeppelin["AdminUpgradeabilityProxy"]["abi"] bytecode = artifacts.open_zeppelin["AdminUpgradeabilityProxy"]["bytecode"] AdminUpgradeabilityProxy = web3.eth.contract(abi=abi, bytecode=bytecode) deploy_txn = AdminUpgradeabilityProxy.constructor( logic, proxyAdmin, web3.toBytes(hexstr="0x")).buildTransaction() tx = deployer.transfer(data=deploy_txn["data"]) return Contract.from_abi(contractName, tx.contract_address, logicAbi)
def test_withdraw(fee_bank_contract: Any, depositor: Account, receiver: Account, accounts: Sequence[Account]) -> None: fee_bank_contract.deposit(receiver, {"from": depositor, "value": 1000}) with brownie.reverts(): fee_bank_contract.withdraw({"from": depositor}) with brownie.reverts(): fee_bank_contract.withdraw(receiver, 1001, {"from": receiver}) different_receiver = accounts[-1] assert different_receiver != receiver receiver_pre_balance = receiver.balance() different_receiver_pre_balance = different_receiver.balance() tx = fee_bank_contract.withdraw(different_receiver, 100, {"from": receiver}) assert fee_bank_contract.deposits(receiver) == 900 assert different_receiver.balance() == different_receiver_pre_balance + 100 assert receiver.balance() == receiver_pre_balance assert len(tx.events) == 1 assert tx.events[0] == { "sender": receiver, "receiver": different_receiver, "amount": 100, "totalAmount": 900, } tx = fee_bank_contract.withdraw({"from": receiver}) assert fee_bank_contract.deposits(receiver) == 0 assert receiver.balance() == receiver_pre_balance + 900 assert different_receiver.balance() == different_receiver_pre_balance + 100 assert len(tx.events) == 1 assert tx.events[0] == { "sender": receiver, "receiver": receiver, "amount": 900, "totalAmount": 0, }
def __init__(cls, alice: Account, ERC20: ContractContainer, xhibit: Contract): cls.alice = alice cls.xhibit = xhibit # create 10 mock ERC20 contracts for i in range(10): instance = alice.deploy(ERC20, f"Test Token {i}", f"TST{i}", 18) # mint a s#!t ton of tokens :) instance._mint_for_testing(alice, 2**256 - 1, {"from": alice}) # approve ahead of time instance.approve(xhibit, 2**256 - 1, {"from": alice}) # create 10 xhibit NFTs as well xhibit.mint(alice, {"from": alice})
def diamond( adam: Account, diamond_cut_facet: ProjectContract, diamond_loupe_facet: ProjectContract, Diamond: ContractContainer, DiamondCut: ContractContainer, DiamondLoupe: ContractContainer, facet_cut_action: FacetCutAction, ) -> ProjectContract: """Deploy the Diamond contract with Cut and Loupe facets.""" init_facet_cuts = [ ( diamond_cut_facet.address, facet_cut_action.ADD, tuple(DiamondCut.selectors.keys()), ), ( diamond_loupe_facet.address, facet_cut_action.ADD, tuple(DiamondLoupe.selectors.keys()), ), ] return adam.deploy(Diamond, init_facet_cuts)
def erc_1820_registry(owner: Account, web3: Web3) -> None: owner.transfer(ERC_1820_DEPLOYMENT_ADDRESS, "0.08 ether") web3.eth.send_raw_transaction(ERC_1820_DEPLOYMENT_TX)
def callproxy(alice: Account, CallProxy: ContractContainer) -> Contract: """Instance of the CallProxy contract.""" return alice.deploy(CallProxy)
def deposit_token_contract( TestDepositTokenContract: ContractContainer, owner: Account, erc_1820_registry: None, ) -> Any: return owner.deploy(TestDepositTokenContract)
def diamond_cut_facet(adam: Account, DiamondCut: ContractContainer) -> ProjectContract: """Deploy the DiamondCut contract.""" return adam.deploy(DiamondCut)
def diamond_loupe_facet(adam: Account, DiamondLoupe: ContractContainer) -> ProjectContract: """Deploy the DiamondLoupe contract.""" return adam.deploy(DiamondLoupe)
def mock_target_contract(MockTargetContract: ContractContainer, owner: Account) -> Any: mock_target_contract = owner.deploy(MockTargetContract) return mock_target_contract
def nft(alice: Account, ERC721: ContractContainer) -> Contract: """Instance of the Xhibit contract.""" return alice.deploy(ERC721)
def mock_batcher_contract(MockBatcherContract: ContractContainer, owner: Account) -> Any: mock_batcher_contract = owner.deploy(MockBatcherContract) return mock_batcher_contract
def xhibit(alice: Account, callproxy: Contract, Xhibit: ContractContainer) -> Contract: """Instance of the Xhibit contract.""" return alice.deploy(Xhibit, callproxy)
def config_contract( ConfigContract: ContractContainer, owner: Account, config_change_heads_up_blocks: int ) -> Any: config_contract = owner.deploy(ConfigContract, config_change_heads_up_blocks) return config_contract