Vote Contract

1
mkdir capstone_aelf
2
cd capstone_aelf

1
dotnet new aelf -n BuildersDAO

1
syntax = "proto3";
2

3
import "aelf/core.proto";
4
import "aelf/options.proto";
5
import "google/protobuf/empty.proto";
6
import "Protobuf/reference/acs12.proto";
7

8
// The namespace of this class
9
option csharp_namespace = "AElf.Contracts.BuildersDAO";
10

11
service BuildersDAO {
12
  // The name of the state class the smart contract is going to use to access
13
  // blockchain state
14
  option (aelf.csharp_state) = "AElf.Contracts.BuildersDAO.BuildersDAOState";
15
  option (aelf.base) = "Protobuf/reference/acs12.proto";
16

17
  // Actions -> Methods that change state of smart contract
18
  // This method sets up the initial state of our StackUpDAO smart contract
19
  rpc Initialize(google.protobuf.Empty) returns (google.protobuf.Empty);
20
  
21
  // This method allows a user to become a member of the DAO by taking in their
22
  // address as an input parameter
23
  rpc JoinDAO(aelf.Address) returns (google.protobuf.Empty);
24
  
25
  // This method allows a user to create a proposal for other users to vote on.
26
  // The method takes in a "CreateProposalInput" message which comprises of an
27
  // address, a title, description and a vote threshold (i.e how many votes
28
  // required for the proposal to pass)
29
  rpc CreateProposal(CreateProposalInput) returns (Proposal);
30
  
31
  // This method allows a user to vote on proposals towards a specific proposal.
32
  // This method takes in a "VoteInput" message which takes in the address of
33
  // the voter, specific proposal and a boolean which represents their vote
34
  rpc VoteOnProposal(VoteInput) returns (Proposal);
35

36
  // Views -> Methods that does not change state of smart contract
37
  // This method allows a user to fetch a list of proposals that had been
38
  // created by members of the DAO
39
  rpc GetAllProposals(google.protobuf.Empty) returns (ProposalList) {
40
    option (aelf.is_view) = true;
41
  }
42
  
43
  // aelf requires explicit getter methods to access the state value, 
44
  // so we provide these three getter methods for accessing the state
45
  // This method allows a user to fetch a proposal by proposalId
46
  rpc GetProposal (google.protobuf.StringValue) returns (Proposal) {
47
    option (aelf.is_view) = true;
48
  }
49

50
  // This method allows a user to fetch the member count that joined DAO
51
  rpc GetMemberCount (google.protobuf.Empty) returns (google.protobuf.Int32Value) {
52
    option (aelf.is_view) = true;
53
  }
54

55
  // This method allows a user to check whether this member is exist by address
56
  rpc GetMemberExist (aelf.Address) returns (google.protobuf.BoolValue) {
57
    option (aelf.is_view) = true;
58
  }
59
}
60

61
// Message definitions
62
message Member {
63
  aelf.Address address = 1;
64
}
65

66
message Proposal {
67
  string id = 1;
68
  string title = 2;
69
  string description = 3;
70
  repeated aelf.Address yesVotes = 4;
71
  repeated aelf.Address noVotes = 5;
72
  string status = 6;  // e.g., "IN PROGRESS", "PASSED", "DENIED"
73
  int32 voteThreshold = 7;
74
}
75

76
message CreateProposalInput {
77
  aelf.Address creator = 1;
78
  string title = 2;
79
  string description = 3;
80
  int32 voteThreshold = 4;
81
}
82

83
message VoteInput {
84
  aelf.Address voter = 1;
85
  string proposalId = 2;
86
  bool vote = 3;  // true for yes, false for no
87
}
88

89
message MemberList {
90
  repeated Member members = 1;
91
}
92

93
message ProposalList {
94
  repeated Proposal proposals = 1;
95
}

1
using System.Collections.Generic;
2
using System.Diagnostics.CodeAnalysis;
3
using AElf.Sdk.CSharp.State;
4
using AElf.Types;
5

6
namespace AElf.Contracts.BuildersDAO
7
{
8
    // The state class is access the blockchain state
9
    public class BuildersDAOState : ContractState
10
    {
11
        public BoolState Initialized { get; set; }
12
        public MappedState<Address, bool> Members { get; set; }
13
        public MappedState<string, Proposal> Proposals { get; set; }
14
        public Int32State MemberCount { get; set; }
15
        public Int32State NextProposalId { get; set; }
16
    }
17
}

1
using System.Collections.Generic;
2
using System.Security.Principal;
3
using AElf.Sdk.CSharp;
4
using AElf.Sdk.CSharp.State;
5
using AElf.Types;
6
using Google.Protobuf.WellKnownTypes;
7

8
namespace AElf.Contracts.BuildersDAO
9
{
10
    public class BuildersDAO : BuildersDAOContainer.BuildersDAOBase
11
    {
12
        const string author = "REPLACE PLACEHOLDER HERE";
13

14
        // Implement Initialize Smart Contract Logic
15
        public override Empty Initialize(Empty input) { }
16

17
        // Implement Join DAO Logic
18
        public override Empty JoinDAO(Address input) { }
19

20
        // Implement Create Proposal Logic
21
        public override Proposal CreateProposal(CreateProposalInput input) { }
22

23
        // Implement Vote on Proposal Logic
24
        public override Proposal VoteOnProposal(VoteInput input) { }
25

26
        // Implement Get All Proposals Logic
27
        public override ProposalList GetAllProposals(Empty input) { }
28
        
29
        // Implement Get Proposal Logic
30
        public override Proposal GetProposal(StringValue input) { }
31
        
32
        // Implement Get Member Count Logic
33
        public override Int32Value GetMemberCount(Empty input) { }
34
        
35
        // Implement Get Member Exist Logic
36
        public override BoolValue GetMemberExist(Address input) { }
37
    }
38
}

1
// Implement Initialize Smart Contract Logic
2
public override Empty Initialize(Empty input)
3
{
4
    Assert(!State.Initialized.Value, "already initialized");
5
    var initialProposal = new Proposal
6
    {
7
        Id = "0",
8
        Title = "Proposal #1",
9
        Description = "This is the first proposal of the DAO",
10
        Status = "IN PROGRESS",
11
        VoteThreshold = 1,
12
    };
13
    State.Proposals[initialProposal.Id] = initialProposal;
14
    State.NextProposalId.Value = 1;
15
    State.MemberCount.Value = 0;
16
    
17
    State.Initialized.Value = true;
18
    
19
    return new Empty();
20
}

1
// Implement Join DAO Logic
2
public override Empty JoinDAO(Address input)
3
{
4
    // Based on the address, determine whether the address has joined the DAO. If it has, throw an exception
5
    // If the address has not joined the DAO, then join and update the state's value to true
6
    // Read the value of MemberCount in the state, increment it by 1, and update it in the state
7
    // Using 'return null' to ensure the contract compiles successfully. Please update it to the correct return value when implementing
8
    return null;
9
}

1
// Implement Create Proposal Logic
2
public override Proposal CreateProposal(CreateProposalInput input)
3
{
4
    Assert(State.Members[input.Creator], "Only DAO members can create proposals");
5
    var proposalId = State.NextProposalId.Value.ToString();
6
    var newProposal = new Proposal
7
    {
8
        Id = proposalId,
9
        Title = input.Title,
10
        Description = input.Description,
11
        Status = "IN PROGRESS",
12
        VoteThreshold = input.VoteThreshold,
13
        YesVotes = { }, // Initialize as empty
14
        NoVotes = { }, // Initialize as empty
15
    };
16
    State.Proposals[proposalId] = newProposal;
17
    State.NextProposalId.Value += 1;
18
    return newProposal; // Ensure return
19
}

1
// Implement Vote on Proposal Logic
2
public override Proposal VoteOnProposal(VoteInput input)
3
{
4
    Assert(State.Members[input.Voter], "Only DAO members can vote");
5
    var proposal = State.Proposals[input.ProposalId]; // ?? new proposal
6
    Assert(proposal != null, "Proposal not found");
7
    Assert(
8
        !proposal.YesVotes.Contains(input.Voter) && !proposal.NoVotes.Contains(input.Voter),
9
        "Member already voted"
10
    );
11

12
    // Add the vote to the appropriate list
13
    if (input.Vote)
14
    {
15
        proposal.YesVotes.Add(input.Voter);
16
    }
17
    else
18
    {
19
        proposal.NoVotes.Add(input.Voter);
20
    }
21

22
    // Update the proposal in state
23
    State.Proposals[input.ProposalId] = proposal;
24

25
    // Check if the proposal has reached its vote threshold
26
    if (proposal.YesVotes.Count >= proposal.VoteThreshold)
27
    {
28
        proposal.Status = "PASSED";
29
    }
30
    else if (proposal.NoVotes.Count >= proposal.VoteThreshold)
31
    {
32
        proposal.Status = "DENIED";
33
    }
34

35
    return proposal;
36
}

1
// Implement Get All Proposals Logic
2
public override ProposalList GetAllProposals(Empty input)
3
{
4
    // Create a new list called ProposalList
5
    // Start iterating through Proposals from index 0 until the value of NextProposalId, read the corresponding proposal, add it to ProposalList, and finally return ProposalList
6
    // Using 'return null' to ensure the contract compiles successfully. Please update it to the correct return value when implementing
7
    return null;
8
}

1
// Implement Get Proposal Logic
2
public override Proposal GetProposal(StringValue input)
3
{
4
    var proposal = State.Proposals[input.Value];
5
    return proposal;
6
}
7

8
// Implement Get Member Count Logic
9
public override Int32Value GetMemberCount(Empty input)
10
{
11
    var memberCount = new Int32Value {Value = State.MemberCount.Value};
12
    return memberCount;
13
}
14

15
// Implement Get Member Exist Logic
16
public override BoolValue GetMemberExist(Address input)
17
{
18
    var exist = new BoolValue {Value = State.Members[input]};
19
    return exist;
20
}

1
public override Empty JoinDAO(Address input)
2
{
3
    // Based on the address, determine whether the address has joined the DAO. If it has, throw an exception
4
    Assert(!State.Members[input], "Member is already in the DAO");
5
    // If the address has not joined the DAO, then join and update the state's value to true
6
    State.Members[input] = true;
7
    // Read the value of MemberCount in the state, increment it by 1, and update it in the state
8
    var currentCount = State.MemberCount.Value;
9
    State.MemberCount.Value = currentCount + 1;
10
    return new Empty();
11
}

1
public override ProposalList GetAllProposals(Empty input)
2
{
3
    // Create a new list called ProposalList
4
    var proposals = new ProposalList();
5
    // Start iterating through Proposals from index 0 until the value of NextProposalId, read the corresponding proposal, add it to ProposalList, and finally return ProposalList
6
    for (var i = 0; i < State.NextProposalId.Value; i++)
7
    {
8
        var proposalCount = i.ToString();
9
        var proposal = State.Proposals[proposalCount];
10
        proposals.Proposals.Add(proposal);
11
    }
12
    return proposals;
13
}

1
aelf-command create

1
? Save account info into a file? (Y/n) Y

1
export WALLET_PASSWORD="YOUR_WALLET_PASSWORD"

1
export CONTRACT_PATH=$(find ~+ . -path "*patched*" | head -n 1)

1
aelf-deploy -a $WALLET_ADDRESS -p $WALLET_PASSWORD -c $CONTRACT_PATH -e https://tdvw-test-node.aelf.io/

1
export CONTRACT_ADDRESS="YOUR_SMART_CONTRACT_ADDRESS e.g. 2LUmicHyH4RXrMjG4beDwuDsiWJESyLkgkwPdGTR8kahRzq5XS"

1
git clone https://github.com/AElfProject/vote-contract-frontend.git

1
cd vote-contract-frontend

1
npm install

1
//Step A - Setup Portkey Wallet Provider
2
useEffect(() => {
3
  (async () => {
4
    if (!provider) return null;
5

6
    try {
7
      // 1. get the sidechain tDVW using provider.getChain
8
      const chain = await provider?.getChain("tDVW");
9
      if (!chain) throw new Error("No chain");
10

11
      //Address of DAO Smart Contract
12
      //Replace with Address of Deployed Smart Contract
13
      const address = "2GkJoDicXLqo7cR9YhjCEnCXQt8KUFUTPfCkeJEaAxGFYQo2tb";
14

15
      // 2. get the DAO contract
16
      const daoContract = chain?.getContract(address);
17
      setSmartContract(daoContract);
18
    } catch (error) {
19
      console.log(error, "====error");
20
    }
21
  })();
22
}, [provider]);

1
const connect = async () => {
2
  //Step B - Connect Portkey Wallet
3
  const accounts = await provider?.request({
4
    method: MethodsBase.REQUEST_ACCOUNTS,
5
  });
6
  const account = accounts?.tDVW?.[0];
7
  setCurrentWalletAddress(account);
8
  setIsConnected(true);
9
  alert("Successfully connected");
10
};

1
const initializeAndJoinDAO = async () => {
2
  //Step C - Write Initialize Smart Contract and Join DAO Logic
3
  try {
4
    const accounts = await provider?.request({
5
      method: MethodsBase.ACCOUNTS,
6
    });
7
    if (!accounts) throw new Error("No accounts");
8

9
    const account = accounts?.tDVW?.[0];
10
    if (!account) throw new Error("No account");
11

12
    if (!initialized) {
13
      await DAOContract?.callSendMethod("Initialize", account, {});
14
      setInitialized(true);
15
      alert("DAO Contract Successfully Initialized");
16
    }
17

18
    await DAOContract?.callSendMethod("JoinDAO", account, account);
19
    setJoinedDAO(true);
20
    alert("Successfully Joined DAO");
21
  } catch (error) {
22
    console.error(error, "====error");
23
  }
24
};

1
//Step D - Configure Proposal Form
2
const form = useForm<z.infer<typeof formSchema>>({
3
  resolver: zodResolver(formSchema),
4
  defaultValues: {
5
    address: currentWalletAddress,
6
    title: "",
7
    description: "",
8
    voteThreshold: 0,
9
  },
10
});

1
// Step E - Write Create Proposal Logic
2
function onSubmit(values: z.infer<typeof formSchema>) {
3
  const proposalInput: IProposalInput = {
4
    creator: currentWalletAddress,
5
    title: values.title,
6
    description: values.description,
7
    voteThreshold: values.voteThreshold,
8
  };
9

10
  setCreateProposalInput(proposalInput);
11

12
  const createNewProposal = async () => {
13
    try {
14
      await DAOContract?.callSendMethod(
15
        "CreateProposal",
16
        currentWalletAddress,
17
        createProposalInput
18
      );
19

20
      navigate("/");
21
      alert("Successfully created proposal");
22
    } catch (error) {
23
      console.error(error);
24
    }
25
  };
26

27
  createNewProposal();
28
}

1
const voteYes = async (index: number) => {
2
  //Step F - Write Vote Yes Logic
3
  try {
4
    const accounts = await provider?.request({
5
      method: MethodsBase.ACCOUNTS,
6
    });
7

8
    if (!accounts) throw new Error("No accounts");
9

10
    const account = accounts?.tDVW?.[0];
11

12
    if (!account) throw new Error("No account");
13

14
    const createVoteInput: IVoteInput = {
15
      voter: account,
16
      proposalId: index,
17
      vote: true,
18
    };
19

20
    await DAOContract?.callSendMethod(
21
      "VoteOnProposal",
22
      account,
23
      createVoteInput
24
    );
25
    alert("Voted on Proposal");
26
    setHasVoted(true);
27
  } catch (error) {
28
    console.error(error, "=====error");
29
  }
30
};

1
useEffect(() => {
2
  // Step G - Use Effect to Fetch Proposals
3
  const fetchProposals = async () => {
4
    try {
5
      const accounts = await provider?.request({
6
        method: MethodsBase.ACCOUNTS,
7
      });
8

9
      if (!accounts) throw new Error("No accounts");
10

11
      const account = accounts?.tDVW?.[0];
12

13
      if (!account) throw new Error("No account");
14

15
      const proposalResponse = await DAOContract?.callViewMethod<IProposals>(
16
        "GetAllProposals",
17
        ""
18
      );
19

20
      setProposals(proposalResponse?.data);
21
      alert("Fetched Proposals");
22
    } catch (error) {
23
      console.error(error);
24
    }
25
  };
26

27
  fetchProposals();
28
}, [DAOContract, hasVoted, isConnected, joinedDAO]);

1
npm run dev