address comments

cairo/token/src/starknet_token.cairo

@@ -27,10 +27,7 @@ mod StarknetToken {
     }
 
     #[constructor]
-    fn constructor(ref self: ContractState, initial_supply: u256, recipient: ContractAddress) {
-        let name = "MyToken";
-        let symbol = "MTK";
-
+    fn constructor(ref self: ContractState, name: ByteArray, symbol: ByteArray, initial_supply: u256, recipient: ContractAddress) {
         self.erc20.initializer(name, symbol);
         self.erc20._mint(recipient, initial_supply);
     }

kakarot_scripts/deployment/dualvm_token_deployments.py

@@ -35,14 +35,15 @@
 
 async def deploy_starknet_token() -> Any:
     owner = await get_starknet_account()
-    address = await deploy_starknet("StarknetToken", int(1e18), owner.address)
+    address = await deploy_starknet(
+        "StarknetToken", "MyToken", "MTK", int(1e18), owner.address
+    )
     return get_contract_starknet("StarknetToken", address=address)
 
 
 async def deploy_dualvm_token(
     kakarot_address: str, starknet_token_address: str, deployer_account: Any = None
 ) -> Any:
-    breakpoint()
     dual_vm_token = await deploy_kakarot(
         "CairoPrecompiles",
         "DualVmToken",
@@ -64,50 +65,48 @@ async def deploy_dualvm_tokens() -> None:
     # %% Deploy DualVM Tokens
     kakarot = get_starknet_deployments()["kakarot"]
     evm_deployments = get_evm_deployments()
-    tokens = await get_tokens(NETWORK)
+    tokens = get_tokens_list(NETWORK)
 
     for token in tokens:
-        token_name = token["name"]
-        if token_name not in evm_deployments:
-            await deploy_new_token(token_name, token, kakarot, evm_deployments)
+        if token["name"] not in evm_deployments:
+            await deploy_new_token(token, kakarot, evm_deployments)
         else:
-            await verify_and_update_existing_token(
-                token_name, token, kakarot, evm_deployments
-            )
+            await verify_and_update_existing_token(token, kakarot, evm_deployments)
 
     logger.info("Finished processing all tokens")
     dump_evm_deployments(evm_deployments)
     logger.info("Updated EVM deployments have been saved")
     # %%
 
 
-async def get_tokens(network) -> List[Dict[str, Any]]:
+def get_tokens_list(network) -> List[Dict[str, Any]]:
     """
     Get the list of tokens for a given network.
     If in dev mode, will return the sepolia token list.
     """
     if network["type"] == NetworkType.DEV:
-        return await load_tokens("sepolia")
-    if network["name"] not in ("mainnet", "sepolia"):
-        raise ValueError(f"No known token addresses for network: {network['name']}")
-    return await load_tokens(network["name"])
+        return load_tokens("sepolia")
+
+    return load_tokens(network["name"])
+
 
+def load_tokens(network_name: str) -> List[Dict[str, Any]]:
+    file_path = TOKEN_ADDRESSES_DIR / f"{network_name}.json"
+    if not file_path.exists():
+        raise ValueError(f"No known token addresses for network: {network_name}")
 
-async def load_tokens(network_name: str) -> List[Dict[str, Any]]:
-    file_name = network_name.replace("starknet-", "")
-    file_path = TOKEN_ADDRESSES_DIR / f"{file_name}.json"
     return json.loads(file_path.read_text())
 
 
 async def deploy_new_token(
-    token_name: str,
     token: Dict[str, Any],
     kakarot: str,
     evm_deployments: Dict[str, Any],
 ) -> None:
     """
-    Deploys a new DualVMToken for a corresponding Starknet ERC20 token.
+    Deploy a new DualVMToken for a corresponding Starknet ERC20 token.
     """
+    token_name = token["name"]
     l2_token_address = await ensure_starknet_token(token_name, token)
     contract = await deploy_dualvm_token(kakarot, l2_token_address)
     evm_deployments[token_name] = {
@@ -120,14 +119,14 @@ async def deploy_new_token(
 
 
 async def verify_and_update_existing_token(
-    token_name: str,
     token: Dict[str, Any],
     kakarot: str,
     evm_deployments: Dict[str, Any],
 ) -> None:
     """
     Given an existing DualVMToken, verifies it is _actually_ deployed. If not, deploys a new one.
     """
+    token_name = token["name"]
     dualvm_token_address = evm_deployments[token_name]["starknet_address"]
     if not await get_class_hash_at(dualvm_token_address):
         l2_token_address = await ensure_starknet_token(token_name, token)

tests/end_to_end/CairoPrecompiles/test_dual_vm_token.py

@@ -13,13 +13,32 @@
 from tests.utils.errors import cairo_error
 
 
+@pytest_asyncio.fixture(scope="session")
+async def dual_vm_token(owner):
+    evm_deployments = get_evm_deployments()
+    ether = evm_deployments["Ether"]["address"]
+    return await get_contract_evm(
+        "CairoPrecompiles",
+        "DualVmToken",
+        address=ether,
+        caller_eoa=owner.starknet_contract,
+    )
+
+
+@pytest_asyncio.fixture(scope="session")
+async def starknet_token(dual_vm_token):
+    starknet_address = await dual_vm_token.starknetToken()
+    deployer = await get_starknet_account()
+    return get_contract_starknet(
+        "StarknetToken", address=starknet_address, provider=deployer
+    )
+
+
 @pytest_asyncio.fixture(scope="function", autouse=True)
 async def fund_owner(owner, starknet_token, max_fee):
-    breakpoint()
     (balance_before,) = await starknet_token.functions["balance_of"].call(
         owner.starknet_contract.address
     )
-    breakpoint()
 
     amount = int(1e16)
     if balance_before > amount:
@@ -40,27 +59,6 @@ async def fund_owner(owner, starknet_token, max_fee):
     ), f"Transfer failed. Expected min balance: {amount}, Actual balance: {balance}"
 
 
-@pytest_asyncio.fixture(scope="function")
-async def starknet_token(dual_vm_token):
-    starknet_address = await dual_vm_token.starknetToken()
-    deployer = await get_starknet_account()
-    return get_contract_starknet(
-        "StarknetToken", address=starknet_address, provider=deployer
-    )
-
-
-@pytest_asyncio.fixture(scope="function")
-async def dual_vm_token(owner):
-    evm_deployments = get_evm_deployments()
-    ether = evm_deployments["Ether"]["address"]
-    return await get_contract_evm(
-        "CairoPrecompiles",
-        "DualVmToken",
-        address=ether,
-        caller_eoa=owner.starknet_contract,
-    )
-
-
 @pytest.mark.asyncio(scope="module")
 @pytest.mark.CairoPrecompiles
 class TestDualVmToken:

tests/end_to_end/conftest.py

@@ -86,7 +86,6 @@ async def _factory(amount=0):
         if balance < tx_cost:
             continue
 
-        breakpoint()
         await kakarot_eth.functions["transfer(uint256,uint256)"](
             deployer.address,
             balance - tx_cost,