ساخت یک سیستم رای گیری غیرمتمرکز ساده در Stellar

curl -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
cargo install --locked --version 20.0.0-rc2 soroban-cli

soroban contract init voting-system
cd voting-system

#![no_std]
use soroban_sdk::{contractimpl, symbol_short, vec, Env, Symbol, Vec};

#[derive(Clone)]
pub struct Candidate {
    name: Symbol,
    votes: u32,
}

#[derive(Clone)]
pub struct Voter {
    address: Symbol,
    has_voted: bool,
}

pub struct VotingContract;

#[contractimpl]
impl VotingContract {
    pub fn init(env: Env) -> VecCandidate> {
        let candidates = vec![&env];
        env.storage().set(&symbol_short!("candidates"), &candidates);
        candidates
    }

    pub fn add_candidate(env: Env, name: Symbol) -> VecCandidate> {
        let mut candidates: VecCandidate> = env.storage().get(&symbol_short!("candidates")).unwrap();
        candidates.push_back(Candidate { name, votes: 0 });
        env.storage().set(&symbol_short!("candidates"), &candidates);
        candidates
    }

    pub fn vote(env: Env, voter: Symbol, candidate_index: u32) -> VecCandidate> {
        let mut candidates: VecCandidate> = env.storage().get(&symbol_short!("candidates")).unwrap();
        let mut voters: VecVoter> = env.storage().get(&symbol_short!("voters")).unwrap_or(vec![&env]);

        // Check if voter has already voted
        if let Some(voter_index) = voters.iter().position(|v| v.address == voter) {
            if voters.get(voter_index).unwrap().has_voted {
                panic!("Voter has already cast a vote");
            }
            voters.set(voter_index, &Voter { address: voter, has_voted: true });
        } else {
            voters.push_back(Voter { address: voter, has_voted: true });
        }

        // Increment vote count for the chosen candidate
        let mut candidate = candidates.get(candidate_index).unwrap();
        candidate.votes += 1;
        candidates.set(candidate_index, &candidate);

        env.storage().set(&symbol_short!("candidates"), &candidates);
        env.storage().set(&symbol_short!("voters"), &voters);

        candidates
    }

    pub fn get_results(env: Env) -> VecCandidate> {
        env.storage().get(&symbol_short!("candidates")).unwrap()
    }
}

soroban contract build

soroban config identity generate contract-admin
soroban config network add testnet --rpc-url https://soroban-testnet.stellar.org:443 --network-passphrase "Test SDF Network ; September 2015"
soroban config identity fund contract-admin --network testnet

soroban contract deploy \
    --wasm target/wasm32-unknown-unknown/release/voting_system.wasm \
    --source contract-admin \
    --network testnet

npx create-react-app voting-dapp
cd voting-dapp
npm install @stellar/freighter-api

import React, { useState, useEffect } from 'react';
import { isConnected, getPublicKey, signTransaction } from '@stellar/freighter-api';
import { SorobanRpc, Transaction, xdr } from 'stellar-sdk';

const server = new SorobanRpc.Server("https://soroban-testnet.stellar.org:443");
const contractId = 'YOUR_CONTRACT_ID'; // Replace with your deployed contract ID

function App() {
  const [candidates, setCandidates] = useState([]);
  const [newCandidate, setNewCandidate] = useState('');
  const [selectedCandidate, setSelectedCandidate] = useState('');
  const [walletConnected, setWalletConnected] = useState(false);

  useEffect(() => {
    checkWalletConnection();
    fetchCandidates();
  }, []);

  const checkWalletConnection = async () => {
    const connected = await isConnected();
    setWalletConnected(connected);
  };

  const fetchCandidates = async () => {
    try {
      const result = await server.invokeHostFunction({
        contractId: contractId,
        functionName: 'get_results',
        args: []
      });
      setCandidates(result);
    } catch (error) {
      console.error('Error fetching candidates:', error);
    }
  };

  const addCandidate = async () => {
    if (!newCandidate) return;
    try {
      await server.invokeHostFunction({
        contractId: contractId,
        functionName: 'add_candidate',
        args: [xdr.ScSymbol.fromString(newCandidate)]
      });
      setNewCandidate('');
      fetchCandidates();
    } catch (error) {
      console.error('Error adding candidate:', error);
    }
  };

  const vote = async () => {
    if (!selectedCandidate) return;
    try {
      const publicKey = await getPublicKey();
      const transaction = await server.invokeHostFunction({
        contractId: contractId,
        functionName: 'vote',
        args: [
          xdr.ScSymbol.fromString(publicKey),
          xdr.ScSymbol.fromString(selectedCandidate)
        ]
      });
      const signedTransaction = await signTransaction(transaction.toXDR());
      await server.sendTransaction(signedTransaction);
      fetchCandidates();
    } catch (error) {
      console.error('Error voting:', error);
    }
  };

  return (
    div className="App">
      h1>Stellar Voting dApph1>
      {walletConnected ? (
        
          h2>Add Candidateh2>
          input
            type="text"
            value={newCandidate}
            onChange={(e) => setNewCandidate(e.target.value)}
          />
          button onClick={addCandidate}>Add Candidatebutton>

          h2>Voteh2>
          select onChange={(e) => setSelectedCandidate(e.target.value)}>
            option value="">Select a candidateoption>
            {candidates.map((candidate, index) => (
              option key={index} value={candidate.name}>
                {candidate.name}
              option>
            ))}
          select>
          button onClick={vote}>Votebutton>

          h2>Resultsh2>
          ul>
            {candidates.map((candidate, index) => (
              li key={index}>
                {candidate.name}: {candidate.votes} votes
              li>
            ))}
          ul>
        >
      ) : (
        p>Please connect your Stellar wallet to use this dApp.p>
      )}
    div>
  );
}

export default App;

npm start