Terra E2E tests fixed, asset registration refactoring

bridge/e2e/terra.go

@@ -57,8 +57,8 @@ type TerraClient struct {
 }
 
 const (
-	feeAmount = 10000,
-	feeDenomination = "uluna",
+	feeAmount       = 10000
+	feeDenomination = "uluna"
 )
 
 func (tc TerraClient) lockAssets(t *testing.T, ctx context.Context, token string, amount *big.Int, recipient [32]byte, targetChain uint8, nonce uint32) (*client.TxResponse, error) {
@@ -100,7 +100,7 @@ func (tc TerraClient) lockAssets(t *testing.T, ctx context.Context, token string
 	t.Logf("lockAssetsCall\n %s", lockAssetsCall)
 
 	executeIncreaseAllowance := msg.NewExecuteContract(tc.address, tokenContract, increaseAllowanceCall, msg.NewCoins())
-	executeLockAssets := msg.NewExecuteContract(tc.address, bridgeContract, lockAssetsCall, msg.NewCoins(msg.NewCoin(feeDenomination, feeAmount)))
+	executeLockAssets := msg.NewExecuteContract(tc.address, bridgeContract, lockAssetsCall, msg.NewCoins(msg.NewInt64Coin(feeDenomination, feeAmount)))
 
 	transaction, err := tc.lcdClient.CreateAndSignTx(ctx, client.CreateTxOptions{
 		Msgs: []msg.Msg{

terra/contracts/wormhole/src/contract.rs

@@ -42,6 +42,8 @@ const CHAIN_ID: u8 = 3;
 const FEE_AMOUNT: u128 = 10000;
 const FEE_DENOMINATION: &str = "uluna";
 
+const WRAPPED_ASSET_UPDATING: &str = "updating";
+
 pub fn init<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
     env: Env,
@@ -203,12 +205,11 @@ fn handle_register_asset<S: Storage, A: Api, Q: Querier>(
 ) -> StdResult<HandleResponse> {
     let mut bucket = wrapped_asset(&mut deps.storage);
     let result = bucket.load(asset_id);
-    match result {
-        Ok(_) => {
-            // Asset already registered, return error
-            ContractError::AssetAlreadyRegistered.std_err()
+    let result = result.map_err(|_| ContractError::RegistrationForbidden.std())?;
+    if result != HumanAddr::from(WRAPPED_ASSET_UPDATING) {
+        return ContractError::AssetAlreadyRegistered.std_err();
     }
-        Err(_) => {
+    
     bucket.save(asset_id, &env.message.sender)?;
 
     let contract_address: CanonicalAddr =
@@ -226,8 +227,6 @@ fn handle_register_asset<S: Storage, A: Api, Q: Querier>(
         data: None,
     })
 }
-    }
-}
 
 fn vaa_update_guardian_set<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
@@ -358,8 +357,10 @@ fn vaa_transfer<S: Storage, A: Api, Q: Querier>(
         let mut messages: Vec<CosmosMsg> = vec![];
 
         // Check if this asset is already deployed
-        match wrapped_asset_read(&deps.storage).load(&asset_id) {
-            Ok(contract_addr) => {
+        let contract_addr = wrapped_asset_read(&deps.storage).load(&asset_id).ok();
+        let contract_addr = contract_addr.filter(|addr| addr != &HumanAddr::from(WRAPPED_ASSET_UPDATING));
+
+        if let Some(contract_addr) = contract_addr {
             // Asset already deployed, just mint
             messages.push(CosmosMsg::Wasm(WasmMsg::Execute {
                 contract_addr,
@@ -372,9 +373,10 @@ fn vaa_transfer<S: Storage, A: Api, Q: Querier>(
                 })?,
                 send: vec![],
             }));
-            }
-            Err(_) => {
+        } else {
             // Asset is not deployed yet, deploy and mint
+            wrapped_asset(&mut deps.storage).save(&asset_id, &HumanAddr::from(WRAPPED_ASSET_UPDATING))?;
+
             let state = config_read(&deps.storage).load()?;
             messages.push(CosmosMsg::Wasm(WasmMsg::Instantiate {
                 code_id: state.wrapped_asset_code_id,
@@ -400,7 +402,6 @@ fn vaa_transfer<S: Storage, A: Api, Q: Querier>(
                 label: None,
             }));
         }
-        }
 
         Ok(HandleResponse {
             messages,
@@ -1147,7 +1148,7 @@ mod tests {
     }
 
     #[test]
-    fn valid_lock_deployed_asset() {
+    fn error_lock_deployed_asset() {
         let deps = mock_dependencies(CANONICAL_LENGTH, &[]);
         let mut deps = Extern {
             storage: deps.storage,
@@ -1166,6 +1167,33 @@ mod tests {
             &HumanAddr::from(LOCK_ASSET_ADDR),
             None,
         );
+
+        assert_eq!(result, ContractError::RegistrationForbidden.std_err());
+    }
+
+    #[test]
+    fn valid_lock_deployed_asset() {
+        let deps = mock_dependencies(CANONICAL_LENGTH, &[]);
+        let mut deps = Extern {
+            storage: deps.storage,
+            api: deps.api,
+            querier: LockAssetQuerier {},
+        };
+        do_init_with_guardians(&mut deps, 1);
+
+        let register_msg = HandleMsg::RegisterAssetHook {
+            asset_id: Binary::from(LOCK_ASSET_ID),
+        };
+
+        wrapped_asset(&mut deps.storage).save(&LOCK_ASSET_ID, &HumanAddr::from(WRAPPED_ASSET_UPDATING)).unwrap();
+
+        let result = submit_msg_with_sender(
+            &mut deps,
+            register_msg.clone(),
+            &HumanAddr::from(LOCK_ASSET_ADDR),
+            None,
+        );
+
         assert!(result.is_ok());
 
         let result = submit_msg_with_fee(&mut deps, MSG_LOCK.clone(), Coin::new(10000, "uluna")).unwrap();

terra/contracts/wormhole/src/error.rs

@@ -94,6 +94,10 @@ pub enum ContractError {
     /// Thrown when fee is enabled for the action, but was not sent with the transaction
     #[error("FeeTooLow")]
     FeeTooLow,
+
+    /// Registering asset outside of the wormhole
+    #[error("RegistrationForbidden")]
+    RegistrationForbidden,
 }
 
 impl ContractError {