Content Comparison

// Dao.move
module Dao {
  use DaoSpace;

  struct DaoSignerDelegate {
    cap: SignerCapability, // 托管的签名（这里一旦放进来，就没法再还回去了，且只有一份，没想好是放在space还是放在这里，暂时放这里）
  }
  
  struct Dao {
    voting_delay: u128, // The delay between when a proposal is created, and when the voting starts. A voting_delay of 0 means that as soon as the proposal is created, anyone can vote. A voting_delay of 3600 means that voting will start 3600 seconds after the proposal is created.
    voting_duration: u128, // The duration of the voting period, i.e. how long people will be able to vote for a proposal.
    name: vector<u8>, //人类可识别的名称标识，是否需要？
    creator: address,
    meta_data: vector<u8>, // 空间元数据，编码后存储在链上（可考虑存在链下）
    cap: SpaceCapability
  }
  
  struct/// DaoProposalProposal {data struct.
  /// cap:是否需要通过 ProposalCapabilityDaoT 来区分 Proposal，如果不需要，则需要把 }DAO id 记录在 proposal 中
  /// struct但 DaoProposalSetAction {的泛型无法消除
  struct Proposal<phantom proposal_setDaoT: HashSet<u64store, DaoProposal>Action: store> has }key {
    //初始化过程中分配给 creator 的 cap /// id structof RootCapability has key{}
the proposal
    struct DaoMemberMeta<phontem DaoT> has copy{
    user id: addressu64,
  }      //这里是否需要 DaoT 来区分不同的 Dao？
  //如果不区分的话，同一个用户加入多个 Daocreator 的情况，当前的of IdentifierNFTthe 无法表达proposal
  struct DaoMemberBody<DaoT>{     sbtproposer: Token<DaoT>address,
  }      /// 执行策略：转账when voting begins.
struct ExecutionTransferStrategy<phontem TokenT> {     amountstart_time: u128u64,
    to: address,   }/// when voting ends.
  // 直接创建 Dao   public fun new_dao(end_time: u64,
     creator: &signer,  /// count of voters who voting_delay: u64, 
agree with the proposal
    voting_period: u64,    for_votes: u128,
   min_action_delay: u64) {   /// count of //这里 Account 需要提供一个新的方法，允许用一个账号去创建另外一个 Delegate 账号。voters who're against the proposal
     let signer_cap = Account::create_delegate_account(&signer)；against_votes: u128,
     let dao_signer = Account::create_signer_with_cap(&siger_cap);
     //下面面的操作切换到 dao_signer 身份进行操作
  /// executable after this time.
   let dao = Dao{..};  eta: u64,
  move_to(&dao_signer, dao);      /// 托管after Daohow 账号的long, SignerCapabilitythe 到该合约agreed proposal can be executed.
 move_to(&dao_signer, DaoSignerDelegate{cap: signer_cap});     action_delay: u64,
     issue_member_nft（creator,&dao_signer);   /// how many votes to reach to make the //初始化 dao 的时候无法一次性完成，需要先把 cap 都存到 creator 账号下proposal pass.
        quorum_votes: u128,
//然后按照 plugin 的方式逐步初始化   }   
  /// proposal 将一个账号直接升级为action.
Dao， sender 会变为 Dao 账号   public fun upgrade_to_dao(sender:signer, ...) {action: Option::Option<Action>,
        //基本逻辑同上，省去了创建账号的流程在原来的 Proposal 字段上新增两个字段
    }    block_num: u64, // 这里有个难题是快照高度
 TokenT 从哪里来。   // 一种方法是先生成一个账号，部署合约，然后升级为 dao root_hash: vector<u8> // 快照根hash
另外一种方法是通过 Dao 的合约升级方式进行部署合约}
  fun
issue_member_nft<DaoT>(creator: &signer, dao_signer: &signer){ //Set 上也需要用泛型来区分   
  Token::register<DaoT>(dao_signer);
 struct DaoProposalSet {
   let basemeta = NFT::new_meta_with_image();proposal_set: HashSet<u64, DaoProposal>
  }
  NFT::register_nft_v2<DaoMemberMeta<DaoT>>(dao_signer,
basemeta);  //初始化过程中分配给 creator 的 cap
let creator_address = Signer::address_of(creator);
 struct RootCapability has key{}
  
//  issuestruct 第一个DaoMemberMeta<phontem NFTDaoT> 给has creatorcopy{
    user: letaddress,
meta = DaoMemberMeta<DaoT>{}
  
  //这里是否需要 DaoT 来区分不同的 user:Dao？
creator;  //如果不区分的话，同一个用户加入多个 Dao 的情况，当前的 IdentifierNFT };无法表达
  struct DaoMemberBody<DaoT>{
 //如何初始化 creator 的 sbt？sbt: Token<DaoT>,
  }
 let sbt
= Token::zero<DaoT>();
  // 执行策略：转账
  struct letExecutionTransferStrategy<phontem body =TokenT> DaoMemberBody<DaoT>{
    amount:  sbtu128,
    to: }address,
  }
  let
nft = NFT::mint(basemeta, meta, body)； // 直接创建 Dao
  public   IdentifierNFT::accept<DaoMemberMeta<DaoT>,DaoMemberBody<DaoT>>(creator);fun new_dao(
     IdentifierNFT::grant(dao_creator: &signer, creator);
     voting_delay: u64, 
}     voting_period: u64, 
 // 参与投票方/创建投票方注册到space   public fun register_to_space(
 min_action_delay: u64) {
    signer: &signer,  //这里 Account 需要提供一个新的方法，允许用一个账号去创建另外一个 Delegate 账号。
      broker: address) {let signer_cap = Account::create_delegate_account(&signer)；
     let dao_signer // 创建对应的NFT= Account::create_signer_with_cap(&siger_cap);
  }    // 参与投票方/创建投票方注册到space
下面面的操作切换到 dao_signer 身份进行操作
 // 方便再上一层的DAO调用   publiclet fun regiter_to_space_get_nft(
dao = Dao{..};
     signer: &move_to(&dao_signer, dao);
      broker: address) : Option::Option<NFT<DaoSpace::NFTMeta, DaoSpace::NFTData>> {
  }// 托管 Dao 账号的 SignerCapability 到该合约
     move_to(&dao_signer, DaoSignerDelegate{cap: signer_cap});
     //
 根据 space_broker 来创建对应的proposal   public fun create_proposal<ExecutionStrategy>(issue_member_nft（creator,&dao_signer);
     
   signer: &signer, //初始化 创建者dao 的时候无法一次性完成，需要先把 cap 都存到 creator 账号下
   space_broker: u64, //然后按照 spaceplugin 代理人的方式逐步初始化
  }
  
block_num: u64, // 快照高度将一个账号直接升级为 Dao， sender 会变为 Dao 账号
 root_hash: vector<u8>public // 快照根hash
  );fun upgrade_to_dao(sender:signer, ...) {
      //基本逻辑同上，省去了创建账号的流程
投票  }
public fun do_vote(
  // 这里有个难题是 TokenT 从哪里来。
signer: &signer, // 一种方法是先生成一个账号，部署合约，然后升级为 dao
  // 另外一种方法是通过 broker:Dao address,的合约升级方式进行部署合约
      id: u64, 
fun issue_member_nft<DaoT>(creator: &signer, dao_signer: &signer){
     amount: u128,Token::register<DaoT>(dao_signer);
     let choice:basemeta u8,
= NFT::new_meta_with_image();
     proof: &vector<u8>,NFT::register_nft_v2<DaoMemberMeta<DaoT>>(dao_signer, basemeta);
     let sidecreator_nodes: &vector<u8>) {
address = Signer::address_of(creator);
     // 证明...
 issue 第一个 NFT 给 creator
   // 取本地NFT let meta = DaoMemberMeta<DaoT>{
// 用NFT投票     do_vote_with_nft(broker, id, choice,user: )creator;
     };
     //如何初始化 用NFT来投票creator 的 sbt？
// 方便上层DAO来调用   public fun do_vote_with_nft(
    broker: address,let sbt = Token::zero<DaoT>();
     id:let u64,body =   DaoMemberBody<DaoT>{
choice: u8,     nft: Option::Option<NFT<DaoSpace::NFTMetasbt,
DaoSpace::NFTData>>   ) { }
     let }nft }