Content Comparison

module DaoAccount{
 weight: u128  /// }DaoAccount
    struct structDaoAccount SpaceCapabilityhas key{
  }
   // 创建 space，一个账号只能创建一个（是否只能一个账户创建一个，待讨论） dao_address: address,
public   fun create(signer: &signer, voting_delay: u128, votingsigner_durationcap: u128SignerCapability,
meta_data: &vector<u8>): SpaceCapability;   // 查询 space upgrade_plan_cap: UpgradePlanCapability,
public fun query(broker: address) :}
(u128,
u128, u128);   /// 非托管账号This registercapability can control publicthe Dao funaccount
register(signer: &signer, space_broker: address, cap: &SpaceCapability) : NFT<NFTMeta, NFTBody>;struct DaoAccountCap has store, key{
  // 非托管账号 unregister   public fun unregister(signer dao_address: &signeraddress,
nft:   NFT<NFTMeta, NFTBody>);}
  // NFT 添加权重
  public fun add_weight(signer: &signer, nft: &mut NFT<NFTMeta, NFTBody>, weight: u128);
  // NFT 减少权重 /// Create a new Dao Account and return DaoAccountCap
    /// Dao Account is a delegate account, the `creator` has the `DaoAccountCap` 
    public fun reducecreate_weightaccount(signercreator: &signer, nft): &mutDaoAccountCap;
NFT<NFTMeta,
NFTBody>, weight: u128); }

/// Dao 生成模版，
module ${DaoName}Dao{
  use StarcoinFramework::GenesisDao;
  
  struct ${DaoName} has store{}
    
  const NAME: vector<u8> = b"${DaoName}";

  /// sender should create a DaoAccount before call this entry function.
  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::extract_dao_account_cap(&sender);
  
      let config = GenesisDao::new_dao_config(
          voting_delay,
          voting_period,
          voting_quorum_rate,
          min_action_delay,
          min_proposal_deposit,
      );
      let dao_root_cap = GenesisDao::create_dao<${DaoName}>(dao_account_cap, *&NAME, ${Name}{}, config);
      
      $for_each plugin in $Plugins{
        GenesisDao::install_plugin_with_root_cap<${DaoName}, plugin.Name>(&dao_root_cap, ${plugin.Name}::required_caps());
      }
      GenesisDao::burn_root_cap(dao_root_cap);
  }
  
}

module GenesisDao {

  /// Proposal data struct.
  ///struct 是否需要通过 DaoT 来区分 Proposal，如果不需要，则需要把 DAO id 记录在 proposal 中
  /// 但 Action 的泛型无法消除
  struct Proposal<phantom DaoT: store, Action: store> has keyProposal has store, copy, drop {
        /// id of the proposal
        id: u64,
 
      /// creator of the proposal
        proposer: address,
        /// when voting begins.
        start_time: u64,
        /// when voting ends.

       end_time: u64,
        /// count of voters who agree with the proposal
        for_votes: u128,
        /// count of voters who're against `yes|no|no_with_veto|abstain` with the proposal
        against_votes: u128vector<u128>,
        /// executable after this time.
        eta: u64,
 
      /// after how long, the agreed proposal can be executed.
        action_delay: u64,
 
      /// how many votes to reach to make the proposal pass.
 
      quorum_votes: u128,
 
      /// proposal action.
the block number when submit proposal 
      actionblock_number: Option::Option<Action>u64,
        ///在原来的 Proposalthe 字段上新增两个字段state root of the block which has the  block_num:number u64,
// 快照高度         root_hashstate_root: vector<u8>,
// 快照根hash }

}  struct ProposalAction<Action: store> has //Setstore 上也需要用泛型来区分{
     struct DaoProposalSet { /// id of the proposal
      proposal_setid: HashSet<u64u64, DaoProposal>
  }      //初始化过程中分配给To creatorprevent 的spam, capproposals must be structsubmitted RootCapabilitywith hasa key{}deposit
     struct InstallPluginCapability//TODO hasshould key{support custom Token?
}      structdeposit: ProposalPluginInfo<PluginConfigToken<STC>,
has store> hash key{   /// proposal action.
installer: address,      //通过 BitSet 的不同位置标识插件的不同权限
     capabilities: BitSet,
     config: Option<PluginConfig,
  }
  
  // DaoWithdrawCapability 是一次性的 capability，不能 store，可以 drop
  struct DaoWithdrawCapability has drop{
  }
  
  struct DaoMemberMeta<phontem DaoT> has copy{
    user: address,
  }
  
  //这里是否需要 DaoT 来区分不同的 Dao？
  //如果不区分的话，同一个用户加入多个 Dao 的情况，当前的 IdentifierNFT 无法表达
  struct DaoMemberBody<DaoT>{
    sbt: Token<DaoT>,
  }
  
  // 执行策略：转账
  struct ExecutionTransferStrategy<phontem TokenT> {
    amount: u128,
    to: address,
  }
  
  // 直接创建 Dao
  public fun new_dao(
     creator: &signer, 
     voting_delay: u64, 
     voting_period: u64, 
     min_action_delay: u64) {
     //这里 Account 需要提供一个新的方法，允许用一个账号去创建另外一个 Delegate 账号。
     let signer_cap = Account::create_delegate_account(&signer)；
     let dao_signer = Account::create_signer_with_cap(&siger_cap);
     //下面面的操作切换到 dao_signer 身份进行操作
     let dao = Dao{..};
     move_to(&dao_signer, dao);
     // 托管 Dao 账号的 SignerCapability 到该合约
     move_to(&dao_signer, DaoSignerDelegate{cap: signer_cap});
     
     issue_member_nft（creator,&dao_signer);
     
     //初始化 dao 的时候无法一次性完成，需要先把 cap 都存到 creator 账号下
     //然后按照 plugin 的方式逐步初始化
  }
  
  // 将一个账号直接升级为 Dao， sender 会变为 Dao 账号
  public fun upgrade_to_dao(sender:signer, ...) {
     //基本逻辑同上，省去了创建账号的流程
  }
  
  ///这里好像没办法检测 DaoT 和 dao_address 的关系
  public fun register<DaoT>(creator: &signer, dao_address: address){
      let dao = borrow_global<Dao>(DaoRegsitry::dao_address<DaoT>());
      //check the dao creator and creator args
      DaoRegistry::register<DaoT>(dao_address, dao.id)
  }
  
  fun dao_signer<DaoT>(): signer {
    let signer_cap = borrow_global<DaoSignerDelegate>(DaoRegsitry::dao_address<DaoT>());
    Account::create_signer_with_cap(&siger_cap)
  }
  
  /// _access_key 确保这个调用来自 PluginT 的 Module
  public fun install_proposal_plugin<DaoT, PluginT>(cap: &dao::InstallPluginCapability, _access_key: &PluginT, installer:&signer， capabilites: vector<u8>){
      let dao_signer = dao_signer<DaoT>();
      move_to(&dao_signer, ProposalPluginCapability<PluginT>{
        installer: Signer:address_of(installer),
        capabilites: BiteSet::from_bytes(capabilites),
      })
  }
  
  public fun borrow_withdraw_capability<DaoT, PluginT>(plugin: &PluginT): DaoWithdrawCapability {
      // check capability with ProposalPluginCapability
      DaoWithdrawCapability
  }
  
  public fun withdraw<DaoT, TokenT>(cap: DaoWithdrawCapability, amount: u64): Token<TokenT>{
    let dao_signer = dao_signer<DaoT>();
    Account::withdraw<TokenT>(amount)
  }
  
  struct PluginStorageItem<PluginT, V>{
    item: V,
  }
  
  public fun move_to<DaoT, PluginT, V>(_access_key: &PluginT, item: V){
    let dao_signer = dao_signer<DaoT>();
    move_to(&dao_signer, PluginStorageItem<PluginT>{
      item
    });
  }
  
  // 这里有个难题是 TokenT 从哪里来。
  // 一种方法是先生成一个账号，部署合约，然后升级为 dao
  // 另外一种方法是通过 Dao 的合约升级方式进行部署合约
  fun issue_member_nft<DaoT>(creator: &signer, dao_signer: &signer){
     Token::register<DaoT>(dao_signer);
     let basemeta = NFT::new_meta_with_image();
     NFT::register_nft_v2<DaoMemberMeta<DaoT>>(dao_signer, basemeta);
     let creator_address = Signer::address_of(creator);
     // issue 第一个 NFT 给 creator
     let meta = DaoMemberMeta<DaoT>{
        user: creator;
     };
     //如何初始化 creator 的 sbt？
     let sbt = Token::zero<DaoT>();
     let body = DaoMemberBody<DaoT>{
      sbt,
     }
     let nft = NFT::mint(basemeta, meta, body)；
     IdentifierNFT::accept<DaoMemberMeta<DaoT>,DaoMemberBody<DaoT>>(creator);
     IdentifierNFT::grant(dao_signer, creator);
     
  }
     
  // 参与投票方/创建投票方注册到space
  public fun register_to_space(
      signer: &signer, 
      broker: address) {
      // 创建对应的NFT
  }

  // 参与投票方/创建投票方注册到space
  // 方便再上一层的DAO调用
  public fun regiter_to_space_get_nft(
      signer: &signer, 
      broker: address) : Option::Option<NFT<DaoSpace::NFTMeta, DaoSpace::NFTData>> {
  }
  
  // 根据 space_broker 来创建对应的proposal
  public fun create_proposal<ExecutionStrategy>(
      signer: &signer, // 创建者
      space_broker: u64, // space 代理人
      block_num: u64, // 快照高度
      root_hash: vector<u8> // 快照根hash
  );
  
  // 投票
  public fun do_vote(
      signer: &signer, 
      broker: address,
      id: u64, 
      amount: u128,
      choice: u8,
      proof: &vector<u8>,
      side_nodes: &vector<u8>) {
    // 证明...
    // 取本地NFT
    // 用NFT投票
    do_vote_with_nft(broker, id, choice, );
  }
  
  // 用NFT来投票
  // 方便上层DAO来调用
  public fun do_vote_with_nft(
    broker: address,
    id: u64,
    choice: u8,
    nft: Option::Option<NFT<DaoSpace::NFTMeta, DaoSpace::NFTData>>
  ) {
    
  }
}

module MemberProposalPlugin{
    use StarcoinFramework::GenesisDao::{Self, CapType};
    use StarcoinFramework::Vector;

    struct MemberProposalPlugin has drop{}

    struct MemberJoinAction has store {
        member: address,
        init_sbt: u128,
    }

    public fun required_caps():vector<CapType>{
       Vector::singleton(GenesisDao::member_cap_type())    
    }

    public fun create_proposal<DaoT: store>(sender: &signer, member: address, init_sbt: u128, action_delay: u64){
        let pluginwitness = XPluginMemberProposalPlugin{};
        let withdraw_cap = DaoGenesisDao::borrowacquire_withdrawproposal_capability<DaoTcap<DaoT,XPlugin> MemberProposalPlugin>(&pluginwitness);
        let tokenaction = Dao::withdraw<STC>(&withdraw_cap, 1000); MemberJoinAction{
            //updatemember,
the executor   }      //the entry scriptinit_sbt,
function   public(script) fun execute_proposal_entry<DaoT>(sender: signer, proposal_id: u64){ };
        execute_proposal<DaoT>GenesisDao::create_proposal(&cap, sender, action, proposalaction_iddelay);
    }

    public fun execute_proposal<DaoT: propose<DaoT>store>(sender: &signer, args:vector<u8>, exec_delayproposal_id: u64){
      let action = new_action(args);
      
      let dao_address = Dao::get_dao_address<DaoT>()let witness = MemberProposalPlugin{};
        let proposal_cap_holder = borrow_global<ProposalPluginCapabilityHolder>(dao_addressGenesisDao::acquire_proposal_cap<DaoT, MemberProposalPlugin>(&witness);
        let MemberJoinAction{member, init_sbt} =  DaoGenesisDao::propose<DaoTexecute_proposal<DaoT, MemberProposalPlugin, XAction>MemberJoinAction>(&capproposal_holder.cap, sender, action, exec_delay, exec_delayproposal_id);

 }      public(script) funlet propose_entry<DaoT>(sender:signer, args:vector<u8>, exec_delay: u64){member_cap = GenesisDao::acquire_member_cap<DaoT, MemberProposalPlugin>(&witness);
        proposeGenesisDao::join_member(&sendermember_cap, argsmember, execinit_delaysbt);
    }
}