If you’re trying to update a merchant’s key in a ObjectTable<String, Merchant> and running into errors like “Cannot ignore values without drop ability,” the issue is that in Sui Move, you can’t just delete or replace objects in storage without explicitly handling ownership and types that lack the drop ability. When you change the key inside your Merchant struct, that doesn't automatically update the merchant_to_key table—so you end up with the old key still pointing to the object, while the new key isn't linked at all.

To fix this, you need to manually remove the old entry, update the struct, and then reinsert it using the new key. But because the Merchant struct doesn't have the drop ability, you can't just remove it and ignore the result—you have to store and reuse the returned object. Here's how you can do it properly inside a transaction:

public entry fun update_merchant_key(
    registry: &mut MerchantRegistry,
    old_key: String,
    new_key: String
) {
    // Remove the merchant using the old key and store the returned object
    let merchant = object_table::remove(&mut registry.merchant_to_key, old_key);

    // Update the key field inside the struct
    merchant.key = new_key;

    // Re-insert into the table with the updated key
    object_table::add(&mut registry.merchant_to_key, new_key, merchant);
}

This way, you safely extract the merchant, modify it, and insert it back using the new key—all while respecting Move's ownership rules.

Remember, this is necessary because Move is designed to prevent accidentally dropping or leaking resources. If your Merchant struct doesn't have the drop ability (which is common when it contains a UID), you must always handle it explicitly.

To get a clearer idea of how ObjectTable works and how to handle ownership safely, check the official docs here: https://docs.sui.io/build/move/object-tables.