2 new admin msgs for fixing forked NFTs

packages/ics721/src/error.rs

@@ -27,6 +27,13 @@ pub enum ContractError {
     #[error("NFT not escrowed by ICS721! Owner: {0}")]
     NotEscrowedByIcs721(String),
 
+    #[error("{recipient} not owner of NFT {token_id}! Owner: {owner}")]
+    NotOwnerOfNft {
+        recipient: String,
+        owner: String,
+        token_id: String,
+    },
+
     #[error("only unordered channels are supported")]
     OrderedChannel {},
 
@@ -50,4 +57,12 @@ pub enum ContractError {
 
     #[error("Couldn't find nft contract for this class id: {0}")]
     NoNftContractForClassId(String),
+
+    #[error("Unknown nft contract: {child_collection}, Class Id: {class_id}, Token ID: {token_id} => NFT contract: {cw721_addr}")]
+    NoClassIdForNftContract {
+        child_collection: String,
+        class_id: String,
+        token_id: String,
+        cw721_addr: String,
+    },
 }

packages/ics721/src/execute.rs

@@ -98,7 +98,170 @@ where
             }) => self.execute_receive_nft(deps, env, info, token_id, sender, msg),
             ExecuteMsg::Pause {} => self.execute_pause(deps, info),
             ExecuteMsg::Callback(msg) => self.execute_callback(deps, env, info, msg),
+            ExecuteMsg::AdminCleanAndBurnNft {
+                recipient,
+                token_id,
+                class_id,
+                collection,
+            } => self.execute_admin_clean_and_burn_nft(
+                deps, env, info, recipient, token_id, class_id, collection,
+            ),
+            ExecuteMsg::AdminCleanAndUnescrowNft {
+                recipient,
+                token_id,
+                class_id,
+                collection,
+            } => self.execute_admin_clean_and_unescrow_nft(
+                deps, env, info, recipient, token_id, class_id, collection,
+            ),
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn execute_admin_clean_and_burn_nft(
+        &self,
+        deps: DepsMut,
+        env: Env,
+        info: MessageInfo,
+        recipient: String,
+        token_id: String,
+        child_class_id: String,
+        child_collection: String,
+    ) -> Result<Response<T>, ContractError> {
+        deps.api.addr_validate(&recipient)?;
+        // only admin can call this method
+        let ContractInfoResponse { admin, .. } = deps
+            .querier
+            .query_wasm_contract_info(env.contract.address.to_string())?;
+        if admin.is_some() && info.sender != admin.unwrap() {
+            return Err(ContractError::Unauthorized {});
+        }
+
+        // check given child class id and child collection is the same as stored in the contract
+        let token_id = TokenId::new(token_id);
+        let child_class_id = ClassId::new(child_class_id);
+        let child_collection = deps.api.addr_validate(&child_collection)?;
+        let cw721_addr = CLASS_ID_TO_NFT_CONTRACT.load(deps.storage, child_class_id.clone())?;
+        if cw721_addr != child_collection {
+            return Err(ContractError::NoClassIdForNftContract {
+                child_collection: child_collection.to_string(),
+                class_id: child_class_id.to_string(),
+                token_id: token_id.into(),
+                cw721_addr: cw721_addr.to_string(),
+            });
         }
+
+        // remove incoming channel entry and metadata
+        INCOMING_CLASS_TOKEN_TO_CHANNEL
+            .remove(deps.storage, (child_class_id.clone(), token_id.clone()));
+        TOKEN_METADATA.remove(deps.storage, (child_class_id.clone(), token_id.clone()));
+
+        // check NFT on child collection owned by recipient
+        let maybe_nft_info: Option<UniversalAllNftInfoResponse> = deps
+            .querier
+            .query_wasm_smart(
+                child_collection.clone(),
+                &cw721::Cw721QueryMsg::AllNftInfo {
+                    token_id: token_id.clone().into(),
+                    include_expired: None,
+                },
+            )
+            .ok();
+
+        let mut response =
+            Response::default().add_attribute("method", "execute_admin_clean_and_burn_nft");
+        if let Some(UniversalAllNftInfoResponse { access, .. }) = maybe_nft_info {
+            if access.owner != recipient {
+                return Err(ContractError::NotOwnerOfNft {
+                    recipient: recipient.to_string(),
+                    token_id: token_id.clone().into(),
+                    owner: access.owner.to_string(),
+                });
+            }
+            // burn child NFT
+            let burn_msg = WasmMsg::Execute {
+                contract_addr: child_collection.to_string(),
+                msg: to_json_binary(&cw721::Cw721ExecuteMsg::Burn {
+                    token_id: token_id.clone().into(),
+                })?,
+                funds: vec![],
+            };
+            response = response.add_message(burn_msg);
+        }
+
+        Ok(response)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn execute_admin_clean_and_unescrow_nft(
+        &self,
+        deps: DepsMut,
+        env: Env,
+        info: MessageInfo,
+        recipient: String,
+        token_id: String,
+        home_class_id: String,
+        home_collection: String,
+    ) -> Result<Response<T>, ContractError> {
+        deps.api.addr_validate(&recipient)?;
+        // only admin can call this method
+        let ContractInfoResponse { admin, .. } = deps
+            .querier
+            .query_wasm_contract_info(env.contract.address.to_string())?;
+        if admin.is_some() && info.sender != admin.unwrap() {
+            return Err(ContractError::Unauthorized {});
+        }
+
+        // check given home class id and home collection is the same as stored in the contract
+        let home_class_id = ClassId::new(home_class_id);
+        let home_collection = deps.api.addr_validate(&home_collection)?;
+        let cw721_addr = CLASS_ID_TO_NFT_CONTRACT.load(deps.storage, home_class_id.clone())?;
+        if cw721_addr != home_collection {
+            return Err(ContractError::NoClassIdForNftContract {
+                child_collection: home_collection.to_string(),
+                class_id: home_class_id.to_string(),
+                token_id,
+                cw721_addr: cw721_addr.to_string(),
+            });
+        }
+
+        // remove outgoing channel entry
+        let token_id = TokenId::new(token_id);
+        OUTGOING_CLASS_TOKEN_TO_CHANNEL
+            .remove(deps.storage, (home_class_id.clone(), token_id.clone()));
+
+        // check NFT on home collection owned by ics721 contract
+        let maybe_nft_info: Option<UniversalAllNftInfoResponse> = deps
+            .querier
+            .query_wasm_smart(
+                home_collection.clone(),
+                &cw721::Cw721QueryMsg::AllNftInfo {
+                    token_id: token_id.clone().into(),
+                    include_expired: None,
+                },
+            )
+            .ok();
+
+        let mut response =
+            Response::default().add_attribute("method", "execute_admin_clean_and_unescrow_nft");
+        if let Some(UniversalAllNftInfoResponse { access, .. }) = maybe_nft_info {
+            if access.owner != env.contract.address {
+                return Err(ContractError::NotEscrowedByIcs721(access.owner.to_string()));
+            }
+            // transfer NFT
+            let transfer_msg = WasmMsg::Execute {
+                contract_addr: home_collection.to_string(),
+                msg: to_json_binary(&cw721::Cw721ExecuteMsg::TransferNft {
+                    recipient: recipient.to_string(),
+                    token_id: token_id.clone().into(),
+                })?,
+                funds: vec![],
+            };
+
+            response = response.add_message(transfer_msg);
+        }
+
+        Ok(response)
     }
 
     /// ICS721 may receive an NFT from 2 sources:

packages/ics721/src/msg.rs

@@ -46,6 +46,25 @@ pub enum ExecuteMsg {
     /// Mesages used internally by the contract. These may only be
     /// called by the contract itself.
     Callback(CallbackMsg),
+
+    /// Admin msg in case something goes wrong.
+    /// As a minimum it clean up states (incoming channel and token metadata), and burn NFT if exists.
+    AdminCleanAndBurnNft {
+        recipient: String,
+        token_id: String,
+        class_id: String,
+        collection: String,
+    },
+
+    /// Admin msg in case something goes wrong.
+    /// As a minimum it clean up state (outgoing channel), and transfer NFT if exists.
+    /// - transfer NFT if exists
+    AdminCleanAndUnescrowNft {
+        recipient: String,
+        token_id: String,
+        class_id: String,
+        collection: String,
+    },
 }
 
 #[cw_serde]

packages/ics721/src/testing/integration_tests.rs

@@ -21,7 +21,7 @@ use crate::{
     ibc::Ics721Ibc,
     msg::{CallbackMsg, ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg},
     query::Ics721Query,
-    state::CollectionData,
+    state::{CollectionData, UniversalAllNftInfoResponse},
     token_types::VoucherCreation,
     ContractError,
 };
@@ -353,11 +353,11 @@ impl Test {
                     incoming_proxy,
                     outgoing_proxy,
                     pauser: admin.clone(),
-                    cw721_admin: admin,
+                    cw721_admin: admin.clone(),
                 },
                 &[],
                 "ics721-base",
-                admin_and_pauser.map(|p| app.api().addr_make(&p).to_string()),
+                admin.clone(),
             )
             .unwrap();
 
@@ -510,6 +510,19 @@ impl Test {
             .unwrap()
     }
 
+    fn query_cw721_all_nft_info(&mut self, token_id: String) -> UniversalAllNftInfoResponse {
+        self.app
+            .wrap()
+            .query_wasm_smart(
+                self.source_cw721.clone(),
+                &cw721_base::msg::QueryMsg::<Empty>::AllNftInfo {
+                    token_id,
+                    include_expired: None,
+                },
+            )
+            .unwrap()
+    }
+
     fn execute_cw721_mint(&mut self, owner: Addr) -> Result<String, anyhow::Error> {
         self.nfts_minted += 1;
 
@@ -1992,6 +2005,148 @@ fn test_receive_nft() {
     }
 }
 
+#[test]
+fn test_admin_clean_and_unescrow_nft() {
+    // test case: receive nft from cw721-base
+    {
+        let mut test = Test::new(
+            false,
+            false,
+            None,
+            Some(ICS721_ADMIN_AND_PAUSER.to_string()),
+            cw721_base_contract(),
+            true,
+        );
+        // simplify: mint and escrowed/owned by ics721, as a precondition for receive nft
+        let token_id_escrowed_by_ics721 = test.execute_cw721_mint(test.ics721.clone()).unwrap();
+        let recipient = test.app.api().addr_make("recipient");
+        let token_id_from_owner = test.execute_cw721_mint(recipient.clone()).unwrap();
+        let channel = "channel-0".to_string();
+        test.app
+            .execute_contract(
+                test.source_cw721.clone(),
+                test.ics721.clone(),
+                &ExecuteMsg::ReceiveNft(cw721::Cw721ReceiveMsg {
+                    sender: test.source_cw721_owner.to_string(),
+                    token_id: token_id_escrowed_by_ics721.clone(),
+                    msg: to_json_binary(&IbcOutgoingMsg {
+                        receiver: NFT_OWNER_TARGET_CHAIN.to_string(), // nft owner for other chain, on this chain ics721 is owner
+                        channel_id: channel.clone(),
+                        timeout: IbcTimeout::with_block(IbcTimeoutBlock {
+                            revision: 0,
+                            height: 10,
+                        }),
+                        memo: None,
+                    })
+                    .unwrap(),
+                }),
+                &[],
+            )
+            .unwrap();
+        // check outgoing channel entry
+        let outgoing_channel = test.query_outgoing_channels();
+        assert_eq!(outgoing_channel.len(), 1);
+        let class_id = ClassId::new(test.source_cw721.to_string());
+        assert_eq!(
+            outgoing_channel,
+            vec![(
+                (class_id.to_string(), token_id_escrowed_by_ics721.clone()),
+                channel.clone()
+            )]
+        );
+        // assert nft is escrowed
+        let UniversalAllNftInfoResponse { access, .. } =
+            test.query_cw721_all_nft_info(token_id_escrowed_by_ics721.clone());
+        assert_eq!(access.owner, test.ics721.to_string());
+
+        // non admin can't call
+        let non_admin = test.app.api().addr_make("not_admin");
+        let admin = test.app.api().addr_make(ICS721_ADMIN_AND_PAUSER);
+        let clean_and_burn_msg = ExecuteMsg::AdminCleanAndBurnNft {
+            recipient: recipient.to_string(),
+            token_id: token_id_escrowed_by_ics721.clone(),
+            class_id: class_id.to_string(),
+            collection: test.source_cw721.to_string(),
+        };
+        let err: ContractError = test
+            .app
+            .execute_contract(
+                non_admin.clone(),
+                test.ics721.clone(),
+                &clean_and_burn_msg,
+                &[],
+            )
+            .unwrap_err()
+            .downcast()
+            .unwrap();
+        assert_eq!(err, ContractError::Unauthorized {});
+
+        let clean_and_unescrow_msg = ExecuteMsg::AdminCleanAndUnescrowNft {
+            recipient: recipient.to_string(),
+            token_id: token_id_from_owner.clone(), // not escrowed by ics721
+            class_id: class_id.to_string(),
+            collection: test.source_cw721.to_string(),
+        };
+        let err: ContractError = test
+            .app
+            .execute_contract(
+                admin.clone(),
+                test.ics721.clone(),
+                &clean_and_unescrow_msg,
+                &[],
+            )
+            .unwrap_err()
+            .downcast()
+            .unwrap();
+        assert_eq!(
+            err,
+            ContractError::NotEscrowedByIcs721(recipient.to_string())
+        );
+
+        // unknown class id
+        let clean_and_unescrow_msg = ExecuteMsg::AdminCleanAndUnescrowNft {
+            recipient: recipient.to_string(),
+            token_id: token_id_escrowed_by_ics721.to_string(),
+            class_id: "unknown".to_string(),
+            collection: test.source_cw721.to_string(),
+        };
+        let err: ContractError = test
+            .app
+            .execute_contract(
+                admin.clone(),
+                test.ics721.clone(),
+                &clean_and_unescrow_msg,
+                &[],
+            )
+            .unwrap_err()
+            .downcast()
+            .unwrap();
+        assert_eq!(err, ContractError::Std(StdError::NotFound { kind: "type: cosmwasm_std::addresses::Addr; key: [00, 01, 65, 75, 6E, 6B, 6E, 6F, 77, 6E]".to_string() }));
+
+        let clean_and_unescrow_msg = ExecuteMsg::AdminCleanAndUnescrowNft {
+            recipient: recipient.to_string(),
+            token_id: token_id_escrowed_by_ics721.clone(),
+            class_id: class_id.to_string(),
+            collection: test.source_cw721.to_string(),
+        };
+        test.app
+            .execute_contract(
+                admin.clone(),
+                test.ics721.clone(),
+                &clean_and_unescrow_msg,
+                &[],
+            )
+            .unwrap();
+        // asert outgoing channel entry is removed
+        let outgoing_channel = test.query_outgoing_channels();
+        assert_eq!(outgoing_channel.len(), 0);
+        // check nft is unescrowed
+        let UniversalAllNftInfoResponse { access, .. } =
+            test.query_cw721_all_nft_info(token_id_escrowed_by_ics721.clone());
+        assert_eq!(access.owner, recipient.to_string());
+    }
+}
+
 /// In case proxy for ICS721 is defined, ICS721 only accepts receival from proxy - not from nft contract!
 #[test]
 fn test_no_receive_with_proxy() {