Merge branch 'main' into stacks_ampd_v2

Cargo.toml

@@ -50,7 +50,7 @@ goldie = { version = "0.5" }
 heck = "0.5.0"
 hex = "0.4.3"
 integration-tests = { version = "^1.0.0", path = "integration-tests" }
-interchain-token-service = { version = "^1.0.0", path = "contracts/interchain-token-service" }
+interchain-token-service = { version = "^1.1.0", path = "contracts/interchain-token-service" }
 into-inner-derive = { version = "^1.0.0", path = "packages/into-inner-derive" }
 itertools = "0.11.0"
 k256 = { version = "0.13.1", features = ["ecdsa"] }

ampd/src/handlers/multisig.rs

@@ -138,8 +138,8 @@ where
         match pub_keys.get(&self.verifier) {
             Some(pub_key) => {
                 let key_type = match pub_key {
-                    PublicKey::Secp256k1(_) => tofnd::Algorithm::Ed25519,
-                    PublicKey::Ed25519(_) => tofnd::Algorithm::Ecdsa,
+                    PublicKey::Secp256k1(_) => tofnd::Algorithm::Ecdsa,
+                    PublicKey::Ed25519(_) => tofnd::Algorithm::Ed25519,
                 };
 
                 let signature = self

ampd/src/handlers/stacks_verify_msg.rs

@@ -181,7 +181,7 @@ mod tests {
     use cosmrs::tx::Msg;
     use cosmwasm_std;
     use error_stack::Result;
-    use ethers_core::types::{H160, U64};
+    use ethers_core::types::H160;
     use tokio::sync::watch;
     use tokio::test as async_test;
     use voting_verifier::events::{PollMetadata, PollStarted, TxEventConfirmation};
@@ -190,7 +190,7 @@ mod tests {
     use crate::event_processor::EventHandler;
     use crate::handlers::tests::{into_structured_event, participants};
     use crate::stacks::http_client::{Block, Client};
-    use crate::types::{EVMAddress, Hash, TMAddress};
+    use crate::types::{Hash, TMAddress};
     use crate::PREFIX;
 
     #[test]

contracts/interchain-token-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "interchain-token-service"
-version = "1.0.0"
+version = "1.1.0"
 rust-version = { workspace = true }
 edition = { workspace = true }
 

contracts/interchain-token-service/src/contract/execute/interceptors.rs

@@ -299,28 +299,86 @@ pub fn register_custom_token(
         register_token.token_address.clone(),
     )
     .change_context(Error::State)?;
-    ensure!(
-        existing_token.is_none(),
-        Error::TokenAlreadyRegistered(register_token.token_address)
-    );
 
-    state::save_custom_token_metadata(storage, source_chain, register_token)
-        .change_context(Error::State)
+    if let Some(existing_token) = existing_token {
+        ensure!(
+            existing_token.decimals == register_token.decimals,
+            Error::TokenDecimalsMismatch {
+                token_address: register_token.token_address,
+                existing_decimals: existing_token.decimals,
+                new_decimals: register_token.decimals
+            }
+        );
+    } else {
+        state::save_custom_token_metadata(storage, source_chain, register_token)
+            .change_context(Error::State)?;
+    }
+
+    Ok(())
 }
 
 #[cfg(test)]
 mod test {
     use assert_ok::assert_ok;
     use axelar_wasm_std::assert_err_contains;
     use cosmwasm_std::testing::MockStorage;
-    use cosmwasm_std::Uint256;
+    use cosmwasm_std::{HexBinary, Uint256};
     use router_api::ChainNameRaw;
 
-    use super::Error;
+    use super::{register_custom_token, Error};
     use crate::contract::execute::interceptors;
     use crate::msg::TruncationConfig;
     use crate::state::{self, TokenDeploymentType};
-    use crate::{msg, DeployInterchainToken, InterchainTransfer, TokenInstance};
+    use crate::{
+        msg, DeployInterchainToken, InterchainTransfer, RegisterTokenMetadata, TokenInstance,
+    };
+
+    #[test]
+    fn register_custom_token_allows_reregistration() {
+        let mut storage = MockStorage::new();
+        let source_chain = ChainNameRaw::try_from("source-chain").unwrap();
+        let register_token_msg = RegisterTokenMetadata {
+            decimals: 6,
+            token_address: HexBinary::from([0; 32]).try_into().unwrap(),
+        };
+        assert_ok!(register_custom_token(
+            &mut storage,
+            source_chain.clone(),
+            register_token_msg.clone()
+        ));
+        assert_ok!(register_custom_token(
+            &mut storage,
+            source_chain,
+            register_token_msg
+        ));
+    }
+
+    #[test]
+    fn register_custom_token_errors_on_decimals_mismatch() {
+        let mut storage = MockStorage::new();
+        let source_chain = ChainNameRaw::try_from("source-chain").unwrap();
+        let register_token_msg = RegisterTokenMetadata {
+            decimals: 6,
+            token_address: HexBinary::from([0; 32]).try_into().unwrap(),
+        };
+        assert_ok!(register_custom_token(
+            &mut storage,
+            source_chain.clone(),
+            register_token_msg.clone()
+        ));
+        assert_err_contains!(
+            register_custom_token(
+                &mut storage,
+                source_chain,
+                RegisterTokenMetadata {
+                    decimals: 12,
+                    ..register_token_msg
+                }
+            ),
+            Error,
+            Error::TokenDecimalsMismatch { .. }
+        );
+    }
 
     #[test]
     fn apply_scaling_factor_to_amount_when_source_decimals_are_bigger() {

contracts/interchain-token-service/src/contract/execute/mod.rs

@@ -79,8 +79,12 @@ pub enum Error {
     },
     #[error("token not registered {0}")]
     TokenNotRegistered(nonempty::HexBinary),
-    #[error("token already registered {0}")]
-    TokenAlreadyRegistered(nonempty::HexBinary),
+    #[error("attempted to register token {token_address} with {new_decimals} but already registered with {existing_decimals} decimals")]
+    TokenDecimalsMismatch {
+        token_address: nonempty::HexBinary,
+        existing_decimals: u8,
+        new_decimals: u8,
+    },
     #[error("failed to query axelarnet gateway for chain name")]
     FailedToQueryAxelarnetGateway,
 }

contracts/router/src/contract.rs

@@ -1,11 +1,10 @@
-use axelar_wasm_std::{address, killswitch, permission_control, FnExt};
+use axelar_wasm_std::{address, killswitch, migrate_from_version, permission_control, FnExt};
 #[cfg(not(feature = "library"))]
 use cosmwasm_std::entry_point;
 use cosmwasm_std::{
     to_json_binary, Addr, Binary, Deps, DepsMut, Env, MessageInfo, Response, Storage,
 };
 use router_api::error::Error;
-use semver::{Version, VersionReq};
 
 use crate::contract::migrations::v1_1_1;
 use crate::events::RouterInstantiated;
@@ -21,21 +20,13 @@ pub const CONTRACT_NAME: &str = env!("CARGO_PKG_NAME");
 pub const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
 
 #[cfg_attr(not(feature = "library"), entry_point)]
+#[migrate_from_version("1.1")]
 pub fn migrate(
     deps: DepsMut,
     _env: Env,
     msg: MigrateMsg,
 ) -> Result<Response, axelar_wasm_std::error::ContractError> {
-    let old_version = Version::parse(&cw2::get_contract_version(deps.storage)?.version)?;
-    let version_requirement = VersionReq::parse(">= 1.1.0, < 1.2.0")?;
-    assert!(version_requirement.matches(&old_version));
-
     v1_1_1::migrate(deps.storage, msg.chains_to_remove)?;
-
-    // this needs to be the last thing to do during migration,
-    // because previous migration steps should check the old version
-    cw2::set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
-
     Ok(Response::default())
 }
 

packages/axelar-wasm-std-derive/Cargo.toml

@@ -16,11 +16,14 @@ itertools = { workspace = true }
 proc-macro2 = { workspace = true }
 quote = { workspace = true }
 report = { workspace = true }
+semver = { workspace = true }
 syn = { workspace = true }
 thiserror = { workspace = true }
 
 [dev-dependencies]
-axelar-wasm-std = { workspace = true }
+assert_ok = { workspace = true }
+axelar-wasm-std = { workspace = true, features = ["derive"] }
+cw2 = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }