def standard_token_package(ethpm_spec_dir):
standard_token_dir = ethpm_spec_dir / "examples" / "standard-token"
manifest = get_ethpm_spec_manifest("standard-token", "v3.json")
compiler = get_ethpm_local_manifest("standard-token",
"output_v3.json")["contracts"]
contracts_dir = standard_token_dir / "contracts"
return contracts_dir, manifest, compiler
def test_get_contract_factory_with_valid_safe_math_lib_manifest(w3):
safe_math_lib_manifest = get_ethpm_spec_manifest('safe-math-lib', 'v3.json')
safe_math_package = w3.pm.get_package_from_manifest(safe_math_lib_manifest)
safe_math_factory = safe_math_package.get_contract_factory("SafeMathLib")
tx_hash = safe_math_factory.constructor().transact()
tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
safe_math_address = tx_receipt.contractAddress
safe_math_instance = safe_math_package.get_contract_instance("SafeMathLib", safe_math_address)
assert safe_math_instance.functions.safeAdd(1, 2).call() == 3
def owned_package(ethpm_spec_dir):
manifest = get_ethpm_spec_manifest("owned", "v3.json")
# source_id missing `./` prefix in ethpm-spec ("Owned.sol"/"./Owned.sol" though both are valid)
source_obj = manifest['sources'].pop('Owned.sol')
updated_manifest = assoc_in(manifest, ['sources', './Owned.sol'],
source_obj)
compiler = get_ethpm_local_manifest("owned", "output_v3.json")["contracts"]
contracts_dir = ethpm_spec_dir / "examples" / "owned" / "contracts"
return contracts_dir, updated_manifest, compiler
def tmp_ethpmdir(tmp_path):
owned_manifest = get_ethpm_spec_manifest("owned", "v3.json")
ethpmdir = tmp_path / '_ethpm_packages'
ethpmdir.mkdir()
owned_dir = ethpmdir / 'owned'
owned_dir.mkdir()
manifest = owned_dir / 'manifest.json'
manifest.touch()
manifest.write_text(json.dumps(owned_manifest, sort_keys=True, separators=(",", ":")))
return ethpmdir
def test_get_contract_factory_with_valid_escrow_manifest(w3):
escrow_manifest = get_ethpm_spec_manifest("escrow", "v3.json")
escrow_package = w3.pm.get_package_from_manifest(escrow_manifest)
escrow_factory = escrow_package.get_contract_factory('Escrow')
assert escrow_factory.needs_bytecode_linking
safe_send_factory = escrow_package.get_contract_factory('SafeSendLib')
safe_send_tx_hash = safe_send_factory.constructor().transact()
safe_send_tx_receipt = w3.eth.wait_for_transaction_receipt(safe_send_tx_hash)
safe_send_address = safe_send_tx_receipt.contractAddress
linked_escrow_factory = escrow_factory.link_bytecode({"SafeSendLib": safe_send_address})
assert linked_escrow_factory.needs_bytecode_linking is False
escrow_tx_hash = linked_escrow_factory.constructor(w3.eth.accounts[0]).transact()
escrow_tx_receipt = w3.eth.wait_for_transaction_receipt(escrow_tx_hash)
escrow_address = escrow_tx_receipt.contractAddress
escrow_instance = linked_escrow_factory(address=escrow_address)
assert escrow_instance.functions.sender().call() == w3.eth.accounts[0]
def test_deployed_escrow_and_safe_send(escrow_manifest, w3):
# Deploy a SafeSendLib
safe_send_manifest = get_ethpm_spec_manifest("escrow", "v3.json")
safe_send_contract_type = safe_send_manifest["contractTypes"][
"SafeSendLib"]
SafeSend = w3.eth.contract(
abi=safe_send_contract_type["abi"],
bytecode=safe_send_contract_type["deploymentBytecode"]["bytecode"],
)
tx_hash = SafeSend.constructor().transact()
tx_receipt = w3.eth.getTransactionReceipt(tx_hash)
safe_send_address = to_canonical_address(tx_receipt["contractAddress"])
EscrowPackage = Package(escrow_manifest, w3)
EscrowFactory = EscrowPackage.get_contract_factory("Escrow")
LinkedEscrowFactory = EscrowFactory.link_bytecode(
{"SafeSendLib": safe_send_address})
# Deploy an Escrow Contract
escrow_tx_hash = LinkedEscrowFactory.constructor(
"0x4F5B11c860b37b68DE6D14Fb7e7b5f18A9A1bdC0").transact()
escrow_tx_receipt = w3.eth.waitForTransactionReceipt(escrow_tx_hash)
escrow_address = escrow_tx_receipt.contractAddress
# Cannot deploy with an unlinked factory
with pytest.raises(BytecodeLinkingError):
escrow_tx_hash = EscrowFactory.constructor(
"0x4F5B11c860b37b68DE6D14Fb7e7b5f18A9A1bdC0").transact()
# Cannot instantiate a contract instance from an unlinked factory
with pytest.raises(BytecodeLinkingError):
EscrowFactory(escrow_address)
contract_instance = LinkedEscrowFactory(escrow_address)
assert EscrowFactory.needs_bytecode_linking is True
assert LinkedEscrowFactory.needs_bytecode_linking is False
assert isinstance(contract_instance, web3.contract.Contract)
assert safe_send_address in LinkedEscrowFactory.bytecode
assert safe_send_address in LinkedEscrowFactory.bytecode_runtime
assert safe_send_address not in EscrowFactory.bytecode
assert safe_send_address not in EscrowFactory.bytecode_runtime
def fetch_manifest(name, version):
return get_ethpm_spec_manifest(name, version)
def piper_coin_manifest():
return get_ethpm_spec_manifest("piper-coin", "v3.json")
def test_get_contract_factory_raises_insufficient_assets_error(w3):
insufficient_owned_manifest = get_ethpm_spec_manifest('owned', 'v3.json')
owned_package = w3.pm.get_package_from_manifest(
insufficient_owned_manifest)
with pytest.raises(InsufficientAssetsError):
owned_package.get_contract_factory('Owned')
def test_pm_init_with_minimal_manifest(w3):
owned_manifest = get_ethpm_spec_manifest('owned', 'v3.json')
pm = w3.pm.get_package_from_manifest(owned_manifest)
assert pm.name == 'owned'
