able to update DAOExt

build/StarcoinFramework/BuildInfo.yaml

@@ -306,7 +306,7 @@ compiled_package_info:
     ? address: "0x00000000000000000000000000000001"
       name: YieldFarmingV2
     : StarcoinFramework
-  source_digest: 695F4208154FB109E223367B79D9AD3C30261C91BF6F595A3B9D2226BC5103B0
+  source_digest: C2A8ED3808648261C25F3710FE00C7A174ECD66EFA876EC74D6668802EF8AF3E
   build_flags:
     dev_mode: false
     test_mode: false

integration-tests/daospace/dao_ext.exp

@@ -0,0 +1,19 @@
+processed 9 tasks
+
+task 6 'run'. lines 65-74:
+{
+  "gas_used": 970329,
+  "status": "Executed"
+}
+
+task 7 'run'. lines 76-85:
+{
+  "gas_used": 76940,
+  "status": "Executed"
+}
+
+task 8 'run'. lines 87-96:
+{
+  "gas_used": 76940,
+  "status": "Executed"
+}

integration-tests/daospace/dao_ext.move

@@ -0,0 +1,96 @@
+//# init -n dev
+
+//# faucet --addr creator --amount 100000000000
+
+//# faucet --addr alice --amount 10000000000
+
+//# faucet --addr bob --amount 10000000000
+
+//# publish
+module creator::DAOHelper {
+    use StarcoinFramework::DAOAccount;
+    use StarcoinFramework::DAOSpace::{Self, CapType};
+    use StarcoinFramework::Vector;
+    use StarcoinFramework::Option;
+
+    struct X has store, copy, drop {
+        value: u64,
+    }
+
+    const NAME: vector<u8> = b"X";
+
+    /// directly upgrade the sender account to DAOAccount and create DAO
+    public(script) fun create_dao(
+        sender: signer,
+        voting_delay: u64,
+        voting_period: u64,
+        voting_quorum_rate: u8,
+        min_action_delay: u64,
+        min_proposal_deposit: u128, ) {
+        let dao_account_cap = DAOAccount::upgrade_to_dao(sender);
+
+
+        //let dao_signer = DAOAccount::dao_signer(&dao_account_cap);
+        let config = DAOSpace::new_dao_config(
+            voting_delay,
+            voting_period,
+            voting_quorum_rate,
+            min_action_delay,
+            min_proposal_deposit,
+        );
+        let dao_ext = X { value: 0};
+        let dao_root_cap = DAOSpace::create_dao<X>(dao_account_cap, *&NAME, Option::none<vector<u8>>(), Option::none<vector<u8>>(), b"ipfs://description", dao_ext, config);
+        DAOSpace::install_plugin_with_root_cap<X, XPlugin>(&dao_root_cap, required_caps());
+
+        DAOSpace::burn_root_cap(dao_root_cap);
+    }
+
+    struct XPlugin has store, drop {}
+
+    public fun required_caps(): vector<CapType> {
+        let caps = Vector::singleton(DAOSpace::modify_ext_cap_type());
+        caps
+    }
+
+    public fun modify_ext(value: u64): u64 {
+        let witness = XPlugin {};
+        let ext_cap = DAOSpace::acquire_modify_ext_cap<X, XPlugin>(&witness);
+        let X { value } = DAOSpace::modify_ext_with_cap<X, XPlugin>(&ext_cap, X { value });
+        value
+    }
+}
+
+//# block --author 0x1 --timestamp 86400000
+
+//# run --signers creator
+script {
+    use creator::DAOHelper;
+
+    fun main(sender: signer) {
+        // time unit is millsecond
+        DAOHelper::create_dao(sender, 10000, 3600000, 2, 10000, 10);
+    }
+}
+// check: EXECUTED
+
+//# run --signers alice
+script {
+    use creator::DAOHelper;
+
+    fun main(_sender: signer) {
+        let ext_value = DAOHelper::modify_ext(123);
+        assert!(ext_value == 0, 101);
+    }
+}
+// check: EXECUTED
+
+//# run --signers bob
+script {
+    use creator::DAOHelper;
+
+    fun main(_sender: signer) {
+        let ext_value = DAOHelper::modify_ext(234);
+        assert!(ext_value == 123, 101);
+    }
+}
+// check: EXECUTED

sources/daospace/DAOSpace.move

@@ -30,6 +30,7 @@ module StarcoinFramework::DAOSpace {
     const ERR_NFT_ERROR: u64 = 104;
     const ERR_ALREADY_INIT: u64 = 105;
     const ERR_TOKEN_ERROR: u64 = 106;
+    const ERR_DAO_EXT: u64 = 107;
 
     /// member
     const ERR_EXPECT_MEMBER: u64 = 200;
@@ -182,6 +183,9 @@ module StarcoinFramework::DAOSpace {
     /// Create a token burning capability type.
     public fun token_burn_cap_type(): CapType { CapType{code: 10 } }
 
+    /// Create a modifying DAOExt capability type.
+    public fun modify_ext_cap_type(): CapType { CapType{code: 11 } }
+
     /// Create all capability types.
     public fun all_caps(): vector<CapType> {
         let caps = Vector::singleton(install_plugin_cap_type());
@@ -193,6 +197,9 @@ module StarcoinFramework::DAOSpace {
         Vector::push_back(&mut caps, member_cap_type());
         Vector::push_back(&mut caps, proposal_cap_type());
         Vector::push_back(&mut caps, grant_cap_type());
+        Vector::push_back(&mut caps, token_mint_cap_type());
+        Vector::push_back(&mut caps, token_burn_cap_type());
+        Vector::push_back(&mut caps, modify_ext_cap_type());
         caps
     }
 
@@ -217,6 +224,8 @@ module StarcoinFramework::DAOSpace {
 
     struct DAOGrantCap<phantom DAOT, phantom PluginT> has drop {}
 
+    struct DAOModifyExtCap<phantom DAOT, phantom PluginT> has drop {}
+
     struct DAOGrantWithdrawTokenKey<phantom DAOT, phantom PluginT ,phantom TokenT> has key, store{
         /// The total amount of tokens that can be withdrawn by this capability
         total: u128,
@@ -340,7 +349,21 @@ module StarcoinFramework::DAOSpace {
         DAORootCap<DAOT>{}
     }
 
-    // Upgrade account to DAO account and create DAO
+    /// Modify DAOExt with new ext and return the old one.
+    public fun modify_ext_with_cap<DAOT: store, PluginT>(_cap: &DAOModifyExtCap<DAOT, PluginT>, ext: DAOT): DAOT
+    acquires DAOAccountCapHolder, DAOExt {
+        let dao_addr = dao_address<DAOT>();
+        assert!(exists<DAOExt<DAOT>>(dao_addr), Errors::not_published(ERR_DAO_EXT));
+        let DAOExt { ext: old_ext } = move_from<DAOExt<DAOT>>(dao_addr);
+
+        let dao_signer = dao_signer<DAOT>();
+        move_to(&dao_signer, DAOExt{
+            ext
+        });
+        old_ext
+    }
+
+    /// Upgrade account to DAO account and create DAO
     public fun upgrade_to_dao<DAOT: store>(sender: signer, name: vector<u8>, image_data:Option::Option<vector<u8>>, image_url:Option::Option<vector<u8>>, description:vector<u8>, ext: DAOT, config: DAOConfig): DAORootCap<DAOT> acquires DAOEvent{
         let cap = DAOAccount::upgrade_to_dao(sender);
         create_dao<DAOT>(cap, name, image_data, image_url, description, ext, config)
@@ -1049,6 +1072,13 @@ module StarcoinFramework::DAOSpace {
         DAOGrantCap<DAOT, PluginT>{}
     }
 
+    /// Acquire the modifying DAOExt capability
+    /// _witness parameter ensures that the caller is the module which define PluginT
+    public fun acquire_modify_ext_cap<DAOT: store, PluginT>(_witness: &PluginT): DAOModifyExtCap<DAOT, PluginT> acquires InstalledPluginInfo {
+        validate_cap<DAOT, PluginT>(modify_ext_cap_type());
+        DAOModifyExtCap<DAOT, PluginT>{}
+    }
+
     /// Delegate the token mint capability to DAO
     /// _witness parameter ensures that the caller is the module which define PluginT
     public fun delegate_token_mint_cap<DAOT: store, PluginT, TokenT: store>(cap: Token::MintCapability<TokenT>, _witness: &PluginT)