Contract: check domestic asset code for mint notes

- Rename check asset -> check foreign asset to make room for check
  domestic asset code function.
- Only pass required data to check asset code functions
- Set msg.sender in asset code tests
- Add unit tests for domestic asset code check
- Integration test for check domestic asset code

Close #390
Close #353

contracts/contracts/CAPE.sol

@@ -29,6 +29,7 @@ contract CAPE is RecordsMerkleTree, RootStore, AssetRegistry {
 
     bytes public constant CAPE_BURN_MAGIC_BYTES = "TRICAPE burn";
     bytes13 public constant DOM_SEP_FOREIGN_ASSET = "FOREIGN_ASSET";
+    bytes14 public constant DOM_SEP_DOMESTIC_ASSET = "DOMESTIC_ASSET";
 
     event BlockCommitted(uint64 indexed height, bool[] includedNotes);
 
@@ -183,17 +184,39 @@ contract CAPE is RecordsMerkleTree, RootStore, AssetRegistry {
     /// @param erc20Address address of the ERC20 token corresponding to the deposit.
     function depositErc20(RecordOpening memory ro, address erc20Address) public {
         address depositorAddress = msg.sender;
-        _checkAssetCode(ro, erc20Address);
+        _checkForeignAssetCode(ro.assetDef.code, erc20Address);
     }
 
+    /// @notice Checks if the asset definition code is correctly derived from the ERC20 address
+    ///        of the token and the address of the depositor.
     /// @dev requires "view" to access msg.sender
-    function _checkAssetCode(RecordOpening memory ro, address erc20Address) internal view {
+    function _checkForeignAssetCode(uint256 assetDefinitionCode, address erc20Address)
+        internal
+        view
+    {
         bytes memory description = _computeAssetDescription(erc20Address, msg.sender);
-        bytes memory randomBytes = abi.encodePacked(
+        bytes memory randomBytes = bytes.concat(
             keccak256(bytes.concat(DOM_SEP_FOREIGN_ASSET, description))
         );
-        uint256 code = BN254.fromLeBytesModOrder(randomBytes);
-        require(code == ro.assetDef.code, "Wrong asset code");
+        uint256 derivedCode = BN254.fromLeBytesModOrder(randomBytes);
+        require(derivedCode == assetDefinitionCode, "Wrong foreign asset code");
+    }
+
+    /// @notice Checks if the asset definition code is correctly derived from the internal asset code.
+    function _checkDomesticAssetCode(uint256 assetDefinitionCode, uint256 internalAssetCode)
+        internal
+        view
+    {
+        bytes memory randomBytes = bytes.concat(
+            keccak256(
+                bytes.concat(
+                    DOM_SEP_DOMESTIC_ASSET,
+                    bytes32(Transcript.reverseEndianness(internalAssetCode))
+                )
+            )
+        );
+        uint256 derivedCode = BN254.fromLeBytesModOrder(randomBytes);
+        require(derivedCode == assetDefinitionCode, "Wrong domestic asset code");
     }
 
     // TODO consider inlining once asset description is finalized. Until then it's useful
@@ -244,7 +267,7 @@ contract CAPE is RecordsMerkleTree, RootStore, AssetRegistry {
                     comms.add(note.mintComm);
                     comms.add(note.chgComm);
                     includedNotes[i] = true;
-                    // TODO check domestic (aap-native) asset code during verification of a mint note. See https://github.com/SpectrumXYZ/jellyfish-apps/blob/main/aap/src/mint.rs#L157-L159
+                    _checkDomesticAssetCode(note.mintAssetDef.code, note.mintInternalAssetCode);
                     // TODO extract proof for batch verification
                 }
 

contracts/contracts/mocks/TestCAPE.sol

@@ -62,8 +62,15 @@ contract TestCAPE is CAPE {
         return _computeMaxCommitments(newBlock);
     }
 
-    function checkAssetCode(RecordOpening memory ro, address erc20Address) public view {
-        _checkAssetCode(ro, erc20Address);
+    function checkForeignAssetCode(uint256 assetDefinitionCode, address erc20Address) public view {
+        _checkForeignAssetCode(assetDefinitionCode, erc20Address);
+    }
+
+    function checkDomesticAssetCode(uint256 assetDefinitionCode, uint256 internalAssetCode)
+        public
+        view
+    {
+        _checkDomesticAssetCode(assetDefinitionCode, internalAssetCode);
     }
 
     function computeAssetDescription(address erc20Address, address sponsor)

contracts/contracts/mocks/TestCapeTypes.sol

@@ -17,7 +17,7 @@ contract TestCapeTypes {
         return root;
     }
 
-    function checkAssetCode(uint256 code) public pure returns (uint256) {
+    function checkForeignAssetCode(uint256 code) public pure returns (uint256) {
         return code;
     }
 

contracts/rust/src/cape.rs

@@ -268,15 +268,14 @@ mod tests {
     use ethers::prelude::{
         k256::ecdsa::SigningKey, Http, Provider, SignerMiddleware, Wallet, U256,
     };
-    use jf_aap::structs::{
-        AssetCode, AssetCodeSeed, AssetDefinition, AssetPolicy, FreezeFlag, RecordOpening,
-    };
+    use jf_aap::structs::{AssetCode, AssetCodeSeed, InternalAssetCode, RecordOpening};
     use rand::Rng;
 
     use crate::assertion::Matcher;
     use crate::ethereum::{deploy, get_funded_deployer};
     use crate::types::{
-        GenericInto, MerkleRootSol, NullifierSol, RecordCommitmentSol, TestCAPE, TestCapeTypes,
+        AssetCodeSol, GenericInto, InternalAssetCodeSol, MerkleRootSol, NullifierSol,
+        RecordCommitmentSol, TestCAPE, TestCapeTypes,
     };
     use anyhow::Result;
     use jf_aap::keys::UserPubKey;
@@ -764,104 +763,169 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_check_asset_code() -> Result<()> {
+    async fn test_check_foreign_asset_code() -> Result<()> {
         let contract = deploy_cape_test().await;
 
         // Fails for random record opening with random asset code.
         let rng = &mut ark_std::test_rng();
         let ro = RecordOpening::rand_for_test(rng);
         contract
-            .check_asset_code(ro.generic_into::<sol::RecordOpening>(), Address::random())
+            .check_foreign_asset_code(
+                ro.asset_def.code.generic_into::<sol::AssetCodeSol>().0,
+                Address::random(),
+            )
             .call()
             .await
-            .should_revert_with_message("Wrong asset code");
+            .should_revert_with_message("Wrong foreign asset code");
 
-        // Fails for record opening with domestic asset code.
         let erc20_address = Address::random();
-        let domestic_asset_def = AssetDefinition::new(
-            AssetCode::new_domestic(AssetCodeSeed::generate(rng), erc20_address.as_bytes()),
-            AssetPolicy::rand_for_test(rng),
-        )
-        .unwrap();
+        // This is the first account from the test mnemonic
+        // TODO define elsewhere to make it usable from other tests
+        let sponsor = "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266".parse::<Address>()?;
+        let erc20_code = Erc20Code(EthereumAddr(erc20_address.to_fixed_bytes()));
+
+        // Fails for domestic asset code.
+        let domestic_asset_code =
+            AssetCode::new_domestic(AssetCodeSeed::generate(rng), erc20_address.as_bytes());
         contract
-            .check_asset_code(
-                RecordOpening::new(
-                    rng,
-                    1u64,
-                    domestic_asset_def,
-                    UserPubKey::default(),
-                    FreezeFlag::Unfrozen,
-                )
-                .generic_into::<sol::RecordOpening>(),
+            .check_foreign_asset_code(
+                domestic_asset_code.generic_into::<AssetCodeSol>().0,
                 erc20_address,
             )
+            .from(sponsor)
             .call()
             .await
-            .should_revert_with_message("Wrong asset code");
-
-        // TODO This is the first address, we should derive it from TEST_MNEMONIC
-        // msg.sender is the first address derived from TEST_MNEMONIC in hardhat
-        // let sponsor = "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266".parse::<Address>()?;
-        // but Address(0) in geth! why?
-        let sponsor = Address::zero();
-        let erc20_code = Erc20Code(EthereumAddr(erc20_address.to_fixed_bytes()));
+            .should_revert_with_message("Wrong foreign asset code");
 
         // Fails if txn sender address does not match sponsor in asset code.
         let description_wrong_sponsor = erc20_asset_description(
             &erc20_code,
             &EthereumAddr(Address::random().to_fixed_bytes()),
         );
-        let asset_def_wrong_sponsor = AssetDefinition::new(
-            AssetCode::new_foreign(&description_wrong_sponsor),
-            AssetPolicy::rand_for_test(rng),
-        )
-        .unwrap();
-        let ro_wrong_sponsor = RecordOpening::new(
-            rng,
-            1u64,
-            asset_def_wrong_sponsor,
-            UserPubKey::default(),
-            FreezeFlag::Unfrozen,
-        );
+        let asset_code_wrong_sponsor = AssetCode::new_foreign(&description_wrong_sponsor);
         contract
-            .check_asset_code(
-                ro_wrong_sponsor.generic_into::<sol::RecordOpening>(),
+            .check_foreign_asset_code(
+                asset_code_wrong_sponsor.generic_into::<AssetCodeSol>().0,
                 sponsor,
             )
+            .from(sponsor)
             .call()
             .await
-            .should_revert_with_message("Wrong asset code");
+            .should_revert_with_message("Wrong foreign asset code");
 
-        // Create a correct record opening with foreign asset code.
         let description =
             erc20_asset_description(&erc20_code, &EthereumAddr(sponsor.to_fixed_bytes()));
         let asset_code = AssetCode::new_foreign(&description);
-        let asset_def = AssetDefinition::new(asset_code, AssetPolicy::rand_for_test(rng)).unwrap();
-        let ro = RecordOpening::new(
-            rng,
-            1u64,
-            asset_def,
-            UserPubKey::default(),
-            FreezeFlag::Unfrozen,
-        );
 
-        // Fails for record opening with random erc20 address.
+        // Fails for random erc20 address.
         contract
-            .check_asset_code(
-                ro.clone().generic_into::<sol::RecordOpening>(),
+            .check_foreign_asset_code(
+                asset_code.generic_into::<sol::AssetCodeSol>().0,
                 Address::random(),
             )
+            .from(sponsor)
+            .call()
+            .await
+            .should_revert_with_message("Wrong foreign asset code");
+
+        // Passes for correctly derived asset code
+        contract
+            .check_foreign_asset_code(
+                asset_code.generic_into::<sol::AssetCodeSol>().0,
+                erc20_address,
+            )
+            .from(sponsor)
             .call()
             .await
-            .should_revert_with_message("Wrong asset code");
+            .should_not_revert();
+
+        Ok(())
+    }
 
-        // Passes for correct record opening and erc20 address.
+    #[tokio::test]
+    async fn test_check_domestic_asset_code() -> Result<()> {
+        let contract = deploy_cape_test().await;
+
+        // Create a matching pair of codes
+        let rng = &mut ark_std::test_rng();
+        let description = b"aap_usdx";
+        let seed = AssetCodeSeed::generate(rng);
+        let internal_asset_code = InternalAssetCode::new(seed, description);
+        let asset_code = AssetCode::new_domestic(seed, description);
+
+        // Passes for matching asset codes
         contract
-            .check_asset_code(ro.generic_into::<sol::RecordOpening>(), erc20_address)
+            .check_domestic_asset_code(
+                asset_code.generic_into::<AssetCodeSol>().0,
+                internal_asset_code.generic_into::<InternalAssetCodeSol>().0,
+            )
             .call()
             .await
             .should_not_revert();
 
+        // Fails with non-matching description
+        contract
+            .check_domestic_asset_code(
+                AssetCode::new_domestic(seed, b"other description")
+                    .generic_into::<AssetCodeSol>()
+                    .0,
+                internal_asset_code.generic_into::<InternalAssetCodeSol>().0,
+            )
+            .call()
+            .await
+            .should_revert_with_message("Wrong domestic asset code");
+
+        // Fails for foreign asset code
+        contract
+            .check_domestic_asset_code(
+                AssetCode::new_foreign(description)
+                    .generic_into::<AssetCodeSol>()
+                    .0,
+                internal_asset_code.generic_into::<InternalAssetCodeSol>().0,
+            )
+            .call()
+            .await
+            .should_revert_with_message("Wrong domestic asset code");
+
+        // Fails if internal asset code doesn't match (different seed)
+        contract
+            .check_domestic_asset_code(
+                asset_code.generic_into::<AssetCodeSol>().0,
+                InternalAssetCode::new(AssetCodeSeed::generate(rng), description)
+                    .generic_into::<InternalAssetCodeSol>()
+                    .0,
+            )
+            .call()
+            .await
+            .should_revert_with_message("Wrong domestic asset code");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_check_domestic_asset_code_in_submit_cape_block() -> Result<()> {
+        let contract = deploy_cape_test().await;
+        let rng = &mut ark_std::test_rng();
+        let params = TxnsParams::generate_txns(rng, 0, 1, 0);
+
+        contract
+            .add_root(params.merkle_root.generic_into::<MerkleRootSol>().0)
+            .send()
+            .await?
+            .await?;
+
+        let mut block = CapeBlock::generate(params.txns, vec![], UserPubKey::default().address())?;
+
+        // Set a wrong internal asset code on the mint note
+        block.mint_notes[0].mint_internal_asset_code =
+            InternalAssetCode::new(AssetCodeSeed::generate(rng), b"description");
+
+        contract
+            .submit_cape_block(block.into(), vec![])
+            .call()
+            .await
+            .should_revert_with_message("Wrong domestic asset code");
+
         Ok(())
     }