pledge

投票机制设计

公链

说明：转载请说明出处，⽆端盗⽤必追责！

⿊名单功能

使⽤：

1.限制交易，即在gossipswitch提供blacklist，限制某些账户的交易；

2.惩罚机制，如果被列⼊⿊名单，不能参与出块；

设计：

1.发起⿊名单请求（必须是超级节点，才能发起设置⿊名单的请求），附带惩罚原因，或者是公⽰的标记；

2.超级节点对⿊名单的提议内容进⾏审核投票，为了快速达成⼀致，超过1/3节点投票通过即设置；

3.⽀持⿊名单的设置和取消功能，建议投票超过2/3才能取消；

4.投票过程分为两种：投赞成票，弃权（不进⾏投票）；

5.⽀持移除⿊名单，也采⽤投票机制；

6.⼀旦对某个⿊名单进⾏投票，则不能取消；

代码实现：

1pragmasolidity>=0.4.24<0.6.0;

2

3/*

4*安全操作函数

5*SafeMathtoavoiddataoverwrite

6*/

7librarySafeMath{

8functionmul(uinta,uintb)internalpurereturns(uint){

9uintc=a*b;

10require(a==0||c/a==b,"overwriteerror");

11returnc;

12}

13

14functiondiv(uinta,uintb)internalpurereturns(uint){

15require(b>0,"overwriteerror");

16uintc=a/b;

17require(a==b*c+a%b,"overwriteerror");

18returnc;

19}

20

21functionsub(uinta,uintb)internalpurereturns(uint){

22require(b<=a,"overwriteerror");

23returna-b;

24}

25

26functionadd(uinta,uintb)internalpurereturns(uint){

27uintc=a+b;

28require(c>=a&&c>=b,"overwriteerror");

29returnc;

30}

31}

32

33contractJustitiaRight{

34uint256publictotalSupply;

35

36functionlockCount(address_account,uint_count)public;

37functionunlockCount(address_account,uint_count)public;

38functionresidePledge(address_owner)publicviewreturns(uintbalance);

39

40functionbalanceOf(address_owner)publicviewreturns(uint256balance);

41functiontransfer(address_to,uint256_value)publicreturns(boolsuccess);

42functiontransferFrom(address_from,address_to,uint256_value)publicreturns(boolsuccess);

43functionapprove(address_spender,uint256_value)publicreturns(boolsuccess);

44functionallowance(address_owner,address_spender)publicviewreturns(uint256remaining);

45}

46

47contractCandidateManage{

48

49usingSafeMathforuint;

50uint256publictotalPledge;

51uintconstantMINIMUM_PLEDGE_TOKEN=100;

52

53JustitiaRightpublicjustitia;

54

55structCandidate{

56addressaccount;

57uintpledge;//totalsupportpledge

58stringmemo;

59uintranking;

60boolisValid;

61}

62address[]publicCandidateList;

63mapping(address=>Candidate)publiccandidateLookup;

64//mapping(support,totalPledge)

65mapping(address=>uint256)publicbalanceOfPledge;

66

67//eventdefine

68eventApplyToCandidateEvent(address,bool,string);

69

70//criteriasthatbeacandidate

71functioncandidateCriteria(addresscandidate,uint256pledge)privateviewreturns(bool){

72uint256balance=Pledge(candidate);

73if(MINIMUM_PLEDGE_TOKEN<=balance&&balance>=pledge){

74returntrue;

75}

76returnfal;

77}

78

79//roleclassify

80//normal:accountwithPR,whichhasrighttovote

81//participate:normalaccountwhichhasparticipateinvoteandhaspeldgecurrently

82//candidate:accountpledgePRtobeacandidate

83functionisNormal(address_account)publicviewreturns(bool){

84if(!isParticipate(_account)&&!isCandidate(_account)){

85returntrue;

86}

87returnfal;

88}

89

90functionisParticipate(address_account)publicviewreturns(bool){

91if(0!=balanceOfPledge[_account]){

92returntrue;

93}

94returnfal;

95}

96

97functionisCandidate(addressaccount)publicviewreturns(bool){

98returncandidateLookup[account].isValid;

99}

100

101//getaccountbalancestatistic

102functionbalanceStatistic(address_owner)publicviewreturns(uint256balance,uint256pledge){

103require(address(0)!=_owner);

104

105uint256total;

106uint256reside;

107

108total=eOf(_owner);

109reside=Pledge(_owner);

110

111require((reside)==balanceOfPledge[_owner]);

112

113return(total,balanceOfPledge[_owner]);

114}

115

116//getcandidateinformation

117functioncandidateState(addresscandidate)publicviewreturns(uint256,uint256,string){

118require(isCandidate(candidate));

119uintindex;

120for(index=0;index<;index++){

121if(CandidateList[index]==candidate){

122break;

123}

124}

125return(index,candidateLookup[candidate].pledge,candidateLookup[candidate].memo);

126}

127

128//findindextoinrttheaccountbyspecifiedcandidateinCandidateList

129functionfindIndexOfCandidate(uintpledge)privateviewreturns(uint){

130uintindex;

131for(index=0;index<;index++){

132if(candidateLookup[CandidateList[index]].pledge<=pledge){

133break;

134}

135}

136returnindex;

137}

138

139//addapplicanttocandidatelist

140functionaddToCandidateListDescending(addressapplicant,uintpledge)privatereturns(uint){

141uintindex;

142index=findIndexOfCandidate(pledge);

(applicant);

144for(uinti=-1;i>index;i--){

145CandidateList[i]=CandidateList[i-1];

146candidateLookup[CandidateList[i]].ranking=i;

147}

148CandidateList[index]=applicant;

149candidateLookup[CandidateList[index]].ranking=index;

150returnindex;

151}

152

153//candidatelistadjustment

154functionadjustCandidateList(addresscandidate,uintpledge)publicreturns(uint){

155if(!isCandidate(candidate)){

156returnaddToCandidateListDescending(candidate,pledge);

157}

158

159uintcurrentIndex;

160uintrightIndex;

161for(currentIndex=0;currentIndex<;currentIndex++){

162if(CandidateList[currentIndex]==candidate){

163break;

164}

165if(candidateLookup[CandidateList[rightIndex]].pledge>=candidateLookup[candidate].pledge){

166rightIndex++;

167}

168

169}

170

171//adding

172if(rightIndex

173for(uinti=currentIndex;i>rightIndex;i--){

174CandidateList[i]=CandidateList[i-1];

175candidateLookup[CandidateList[i]].ranking=i;

176}

177}el{

178for(uintj=currentIndex;j

179CandidateList[j]=CandidateList[j+1];

180candidateLookup[CandidateList[j]].ranking=j;

181}

182}

183

184CandidateList[rightIndex]=candidate;

185candidateLookup[CandidateList[rightIndex]].ranking=rightIndex;

186returnrightIndex;

187}

188

189//applytocandidate

190functionApplyToCandidate(uintpledge,stringmemo)publicreturns(bool,string){

191require(!isCandidate());

192

193stringmemoryerrors;

194if(!candidateCriteria(,pledge)){

195errors="errors:somecriteriasnotmet.";

196emitApplyToCandidateEvent(,fal,errors);

197return(fal,errors);

198}

199

200totalPledge=(pledge);

unt(,pledge);

202balanceOfPledge[]=balanceOfPledge[].add(pledge);

203adjustCandidateList(,pledge);

204candidateLookup[].memo=memo;

205candidateLookup[].isValid=true;

206candidateLookup[].pledge=candidateLookup[].(pledge);

207candidateLookup[].account=;

208emitApplyToCandidateEvent(,true,errors);

209return(true,errors);

210}

211

212//getcandidates

213functionCandidates()publicviewreturns(address[]){

214returnCandidateList;

215}

216}

217

218

219contractBlackListElection{

220usingSafeMathforuint;

221structBlackListItem{

222stringreason;

223address[]approveAccounts;

224address[]rejectAccounts;

225mapping(address=>bool)approveRecords;

226mapping(address=>bool)rejectRecoeds;

227boolisValid;

228uintindex;

229}

230mapping(address=>BlackListItem)publicblackListItemLookup;

231address[]publicblackListProcessing;

232

233functionisRegiste(address_account)publicviewreturns(bool){

234returnblackListItemLookup[_account].isValid;

235}

236

237functiontoBlackList(address_account,stringreason)publicreturns(uint){

238if(!isRegiste(_account)){

239blackListItemLookup[_account].reason=reason;

240blackListItemLookup[_account].(_account);

241blackListItemLookup[_account].approveRecords[]=true;

242blackListItemLookup[_account].isValid=true;

243blackListItemLookup[_account].index=(_account).sub(1);

244}el{

245if(!blackListItemLookup[_account].approveRecords[]){

246blackListItemLookup[_account].(_account);

247blackListItemLookup[_account].approveRecords[]=true;

248}

249}

250returnblackListItemLookup[_account].;

251}

252

253functionblackListToProcess()publicviewreturns(address[]){

254returnblackListProcessing;

255}

256

257functionremoveBlackList(address_account)public{

258require(isRegiste(_account));

259deleteblackListProcessing[blackListItemLookup[_account].index];

260deleteblackListItemLookup[_account];

261}

262}

263

264

265contractBlackListManageisBlackListElection{

266

267uintpublicthresHoldToAddBlackList;

268uintpublicthresHoldToRrmoveBlackList;

269

270structBlackList{

271uintdate;

272boolisValid;

273}

274mapping(address=>BlackList)publicblackListLookup;

275address[]publicblackList;

276

277eventAddToBlackListEvent(address,string);

278

279functionisInBlackList(address_account)publicviewreturns(bool){

280returnblackListLookup[_account].isValid;

281}

282

283functionvoteForBlacklist(address_account,stringcomment)public{

284uintsupporters=toBlackList(_account,comment);

285if(supporters>=thresHoldToAddBlackList){

286blackListLookup[_account].date=now;

287blackListLookup[_account].isValid=true;

(_account);

289removeBlackList(_account);

290emitAddToBlackListEvent(_account,blackListItemLookup[_account].reason);

291}

292}

293

294functiongetBlackList()publicviewreturns(address[]){

295returnblackList;

296}

297

298}

299

300/*

301*系统合约调⽤

302*管理选举情况，包括：选举，取消选举，选举情况统计等

303*/

304contractElectionManageisCandidateManage,BlackListManage{

305

306usingSafeMathforuint;

307uintpublictotalNodes;

308uintconstantENTRY_HRESHOLD=100;

309boolprivatemainNetSwitch;

310uintconstantMAINNET_ONLINE_THRESHOLD=1000;

311

312eventMainNetOnlineEvent(uint,uint);

313eventIssueVoteEvent(address,address,uint);

314eventAdjustmentVoteEvent(address,address,uint);

315

316structElection{

317boolisValid;

318address[]participates;

319mapping(address=>uint)election;

320}

321//recordcandidateelection

322mapping(address=>Election)privatecandidateElection;

323

324//constructor

325constructor(addresstoken,uintnodeNum)public{

326justitia=JustitiaRight(token);

327totalNodes=nodeNum;

328thresHoldToAddBlackList=(3);

329thresHoldToRrmoveBlackList=(2)+1;

330}

331

332//trytoonlinemainnetwork

333//weassumethatoncemainnetonlie,itwillonlieforever

334functiontryToOnlineMainNet()private{

335//onlystatechanged,emitevent

336if(!mainNetSwitch){

337if(totalPledge>=MAINNET_ONLINE_THRESHOLD){

338mainNetSwitch=true;

339emitMainNetOnlineEvent(now,totalPledge);

340}

341}

342}

343

344//togetthepledgeofparticipateforspecifiedcandidate

345functiongetPledgeFlow(addresscandidate,addressparticipate)publicviewreturns(uint){

346require(isCandidate(candidate));

347returncandidateElection[candidate].election[participate];

348}

349

350//togetallsupportersofthespecifiedcandidate

351functiongetSupportOfCandidate(addresscandidate)publicviewreturns(address[]){

352require(isCandidate(candidate));

353returncandidateElection[candidate].participates;

354}

355

356//getrankofcandidate

357functionranking(address_candidate)publicviewreturns(uint){

358require(isCandidate(_candidate));

359require(address(0)!=_candidate);

360uintindex;

361uintrank;

362for(index=0;index<;index++){

363if(isCandidate(_candidate)){

364rank++;

365if(_candidate==CandidateList[index]){

366returnrank;

367}

368}

369}

370}

371

372//issueaelectionforcandidatewithsomepledges

373functionissueVote(addresscandidate,uintpledge)private{

374require(isCandidate(candidate));

375require(!isCandidate());

376require(pledge<=Pledge());

377

378if(!candidateElection[candidate].isValid){

379candidateElection[candidate].();

380candidateElection[candidate].isValid=true;

381}

382candidateLookup[candidate].pledge=candidateLookup[candidate].(pledge);

383candidateElection[candidate].election[]=candidateElection[candidate].election[].add(pledge);

384adjustCandidateList(candidate,candidateLookup[candidate].pledge);

385balanceOfPledge[]=balanceOfPledge[].add(pledge);

386totalPledge=(pledge);

unt(,pledge);

388

389emitIssueVoteEvent(,candidate,pledge);

390}

391

392//toadjustmentofvotingforspecifiedcandidatewithpledge

393functionadjustmentVote(addresscandidate,uintpledge)private{

394require(isCandidate(candidate));

395require(pledge<=candidateElection[candidate].election[]);

396

397candidateLookup[candidate].pledge=candidateLookup[candidate].(pledge);

398candidateElection[candidate].election[]=candidateElection[candidate].election[].sub(pledge);

399adjustCandidateList(candidate,candidateLookup[candidate].pledge);

400balanceOfPledge[]=balanceOfPledge[].sub(pledge);

401totalPledge=(pledge);

Count(,pledge);

403

404emitAdjustmentVoteEvent(,candidate,pledge);

405}

406

407functionrightToVoteBlackList(address_account)privateviewreturns(bool){

408require(isCandidate(_account));

409if(candidateLookup[_account].ranking

410returntrue;

411}

412returnfal;

413}

414

415functionGetOnlineSymbol()publicviewreturns(bool){

416returnmainNetSwitch;

417}

418

419functionVoteAdjustment(addresscandidate,uintcanceledPledge)public{

420require(isCandidate(candidate));

421adjustmentVote(candidate,canceledPledge);

422}

423

424functionVotting(addresscandidate,uintpledge)public{

425require(isCandidate(candidate));

426issueVote(candidate,pledge);

427tryToOnlineMainNet();

428}

429

430functionSetBlackList(address_account)public{

431require(rightToVoteBlackList());

432if(!isInBlackList(_account)){

433voteForBlacklist(_account,"errors");

434}

435}

436}

ViewCode