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 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 __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 xhibit(alice: Account, callproxy: Contract, Xhibit: ContractContainer) -> Contract:
"""Instance of the Xhibit contract."""
return alice.deploy(Xhibit, callproxy)
def callproxy(alice: Account, CallProxy: ContractContainer) -> Contract:
"""Instance of the CallProxy contract."""
return alice.deploy(CallProxy)
def nft(alice: Account, ERC721: ContractContainer) -> Contract:
"""Instance of the Xhibit contract."""
return alice.deploy(ERC721)
def diamond_loupe_facet(adam: Account,
DiamondLoupe: ContractContainer) -> ProjectContract:
"""Deploy the DiamondLoupe contract."""
return adam.deploy(DiamondLoupe)
def diamond_cut_facet(adam: Account,
DiamondCut: ContractContainer) -> ProjectContract:
"""Deploy the DiamondCut contract."""
return adam.deploy(DiamondCut)
def deposit_token_contract(
TestDepositTokenContract: ContractContainer,
owner: Account,
erc_1820_registry: None,
) -> Any:
return owner.deploy(TestDepositTokenContract)
def mock_target_contract(MockTargetContract: ContractContainer, owner: Account) -> Any:
mock_target_contract = owner.deploy(MockTargetContract)
return mock_target_contract
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
def mock_batcher_contract(MockBatcherContract: ContractContainer, owner: Account) -> Any:
mock_batcher_contract = owner.deploy(MockBatcherContract)
return mock_batcher_contract
