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
