def setup():
network.disconnect()
yield
if not network.is_connected():
network.connect('development')
elif network.show_active() != "development":
network.disconnect()
network.connect('development')
def test_disconnect():
network.disconnect()
assert not network.is_connected()
assert network.show_active() is None
assert not rpc.is_active()
assert not web3.isConnected()
with pytest.raises(ConnectionError):
network.disconnect()
def mainnet_uri():
prev = network.show_active()
if prev:
network.disconnect(False)
network.connect("mainnet")
uri = web3.chain_uri
network.disconnect(False)
if prev:
network.connect(prev)
yield uri
def test_repopulate():
network.rpc.reset()
assert len(accounts) == 10
a = list(accounts)
network.rpc.reset()
assert a == list(accounts)
network.disconnect()
assert len(accounts) == 0
network.connect('development')
assert len(accounts) == 10
assert a != list(accounts)
def main():
acct = accounts.load('TestUser')
network.disconnect()
network.connect('ropsten')
print('----------------------------------------')
print('Ethereum (Ropsten) Minting. ')
print('----------------------------------------')
BrownieWrap_Token.at('0xBD2231994722D8a47244C4166Bc6Ac4bF8Bbc110').mint(
acct, 20, {'from': acct})
network.disconnect()
network.connect('bsc-test')
print('----------------------------------------')
print('Binance Smart Chain Minting')
print('----------------------------------------')
BrownieWrap_Token.at('0x926A513fdd63e1010e6C0627EB12204ADA45d550').mint(
acct, 20, {'from': acct})
def main():
wltBadgerTeam = accounts.load('GasWallet')
network.disconnect()
network.connect('ropsten')
print('----------------------------------------')
print('Deploying Ethereum (Ropsten) contracts. ')
print('----------------------------------------')
ctrBadgerLpToken = BrownieWrap_Token.deploy("Sett Vault Badger LP",
"bBadger",
{'from': wltBadgerTeam},
publish_source=True)
ctrBadgerHolderValidation = TokenHolderThresholdValidator.deploy(
ctrBadgerLpToken.address,
10,
1, {'from': wltBadgerTeam},
publish_source=True)
network.disconnect()
network.connect('bsc-test')
print('----------------------------------------')
print('Deploying Binance Smart Chain contracts.')
print('----------------------------------------')
ctrBadgerLpToken = BrownieWrap_Token.deploy("Sett Vault Badger LP",
"bBadger",
{'from': wltBadgerTeam},
publish_source=True)
ctrBadgerHolderValidation = TokenHolderThresholdValidator.deploy(
ctrBadgerLpToken.address,
10,
1, {'from': wltBadgerTeam},
publish_source=True)
ctrFaucet = Faucet.deploy(10,
Wei("50 gwei"), [], {
'from': wltBadgerTeam,
'value': Wei("500 gwei")
},
publish_source=True)
print('Contract chain deployment complete.')
def wrapper(*args, **kwargs):
initial_network_id = network.show_active()
is_mainnet = "main" in initial_network_id
if environment_name == "ethereum":
swap_network_id = "mainnet" if is_mainnet else "goerli"
elif environment_name == "polygon":
swap_network_id = "polygon-main" if is_mainnet else "polygon-testnet"
if initial_network_id == swap_network_id:
return func(*args, **kwargs)
network.disconnect()
network.connect(swap_network_id)
result = func(*args, **kwargs)
network.disconnect()
network.connect(initial_network_id)
return result
def setup_brownie_mainnet_fork(pytestconfig):
project_root = get_project_root()
# setup the project and network the same way brownie's run helper does
brownie_project = project.load(project_root)
brownie_project.load_config()
# override some config
CONFIG.argv["revert"] = True
network.connect("mainnet-fork")
# TODO: brownie does some other setup for hypothesis and multiple-processes
fixtures = PytestBrownieFixtures(pytestconfig, brownie_project)
pytestconfig.pluginmanager.register(fixtures, "brownie-fixtures")
brownie.reverts = RevertContextManager
yield
network.disconnect()
def test_connect_raises_connected():
with pytest.raises(ConnectionError):
network.connect('development')
network.disconnect()
def create_manifest(project_path: Path,
package_config: Dict,
pin_assets: bool = False,
silent: bool = True) -> Tuple[Dict, str]:
"""
Creates a manifest from a project, and optionally pins it to IPFS.
Arguments:
project_path: Path to the root folder of the project
package_config: Configuration settings for the manifest
pin_assets: if True, all source files and the manifest will
be uploaded onto IPFS via Infura.
Returns: generated manifest, ipfs uri of manifest
"""
package_config = _remove_empty_fields(package_config)
_verify_package_name(package_config["package_name"])
if pin_assets:
ipfs_backend = InfuraIPFSBackend()
manifest = {
"manifest_version": "2",
"package_name": package_config["package_name"],
"version": package_config["version"],
"sources": {},
"contract_types": {},
}
if "meta" in package_config:
manifest["meta"] = package_config["meta"]
# load packages.json and add build_dependencies
packages_json: Dict = {"sources": {}, "packages": {}}
if not package_config["settings"]["include_dependencies"]:
installed, modified = get_installed_packages(project_path)
if modified:
raise InvalidManifest(
f"Dependencies have been modified locally: {', '.join([i[0] for i in modified])}"
)
if installed:
packages_json = _load_packages_json(project_path)
manifest["build_dependencies"] = dict(
(k, v["manifest_uri"])
for k, v in packages_json["packages"].items())
# add sources
contract_path = project_path.joinpath("contracts")
for path in contract_path.glob("**/*.sol"):
if path.relative_to(
project_path).as_posix() in packages_json["sources"]:
continue
if pin_assets:
if not silent:
print(
f'Pinning "{color("bright magenta")}{path.name}{color}"...'
)
uri = ipfs_backend.pin_assets(path)[0]["Hash"]
else:
with path.open("rb") as fp:
uri = generate_file_hash(fp.read())
manifest["sources"][
f"./{path.relative_to(contract_path).as_posix()}"] = f"ipfs://{uri}"
# add contract_types
for path in project_path.glob("build/contracts/*.json"):
with path.open() as fp:
build_json = json.load(fp)
if not build_json["bytecode"]:
# skip contracts that cannot deploy
continue
if build_json["sourcePath"] in packages_json["sources"]:
# skip dependencies
continue
manifest["contract_types"][
build_json["contractName"]] = _get_contract_type(build_json)
# add deployments
deployment_networks = package_config["settings"]["deployment_networks"]
if deployment_networks:
active_network = network.show_active()
if active_network:
network.disconnect()
manifest["deployments"] = {}
if isinstance(deployment_networks, str):
deployment_networks = [deployment_networks]
if deployment_networks == ["*"]:
deployment_networks = [
i.stem for i in project_path.glob("build/deployments/*")
]
for network_name in deployment_networks:
instances = list(
project_path.glob(f"build/deployments/{network_name}/*.json"))
if not instances:
continue
instances.sort(key=lambda k: k.stat().st_mtime, reverse=True)
network.connect(network_name)
manifest["deployments"][web3.chain_uri] = {}
for path in instances:
with path.open() as fp:
build_json = json.load(fp)
alias = build_json["contractName"]
source_path = build_json["sourcePath"]
if source_path in packages_json["sources"]:
alias = f"{packages_json['sources'][source_path]['packages'][0]}:{alias}"
if alias in manifest["contract_types"]:
# skip deployment if bytecode does not match that of contract_type
bytecode = manifest["contract_types"][alias][
"deployment_bytecode"]["bytecode"]
if f"0x{build_json['bytecode']}" != bytecode:
continue
else:
# add contract_type for dependency
manifest["contract_types"][alias] = _get_contract_type(
build_json)
key = build_json["contractName"]
for i in itertools.count(1):
if key not in manifest["deployments"][web3.chain_uri]:
break
key = f"{build_json['contractName']}-{i}"
manifest["deployments"][web3.chain_uri][key] = {
"address": path.stem,
"contract_type": alias,
}
network.disconnect()
if active_network:
network.connect(active_network)
if not manifest["deployments"]:
del manifest["deployments"]
uri = None
if pin_assets:
if not silent:
print("Pinning manifest...")
temp_path = Path(tempfile.gettempdir()).joinpath("manifest.json")
with temp_path.open("w") as fp:
json.dump(manifest, fp, sort_keys=True, separators=(",", ":"))
uri = ipfs_backend.pin_assets(temp_path)[0]["Hash"]
return manifest, uri
