@leofcoin/standards 0.2.16 → 0.3.1

package/src/voting/public-voting.ts

@@ -1,14 +1,134 @@
-import ContractCreator, { ContractCreatorState } from '../contract-creator.js'
-import { VotingState, VoteResult } from './types.js'
-import Voting from './voting.js'
-
-export declare interface PublicVotingState extends VotingState, ContractCreatorState {}
-
-/**
- * allows everybody that has a balance greater or equeal then/to tokenAmountToReceive to vote
- */
-export default class PublicVoting extends Voting {
-  constructor(state: PublicVotingState) {
-    super(state)
-  }
-}
+import Meta from '../meta.js'
+import { VotingState, VoteResult } from './types.js'
+
+/**
+ * allows everybody that has a balance greater or equal to tokenAmountToReceive to vote
+ */
+export default class PublicVoting extends Meta {
+  #votes: VotingState['votes']
+  #votingDisabled: boolean
+  #votingDuration: number = 172800000
+
+  constructor(state: VotingState) {
+    super(state)
+    if (state) {
+      this.#votes = state.votes
+      this.#votingDisabled = state.votingDisabled
+    }
+  }
+
+  get votes() {
+    return { ...this.#votes }
+  }
+
+  get votingDuration() {
+    return this.#votingDuration
+  }
+
+  get votingDisabled() {
+    return this.#votingDisabled
+  }
+
+  /**
+   *
+   */
+  get state() {
+    return {
+      ...super.state,
+      votes: this.#votes,
+      votingDisabled: this.#votingDisabled,
+      votingDuration: this.#votingDuration
+    }
+  }
+
+  get inProgress() {
+    return Object.entries(this.#votes)
+      .filter(([id, vote]) => !vote.finished)
+      .map(([id, vote]) => {
+        return { ...vote, id }
+      })
+  }
+  /**
+   * create vote
+   * @param {string} vote
+   * @param {string} description
+   * @param {number} endTime
+   * @param {string} method function to run when agree amount is bigger
+   */
+
+  createVote(
+    title: string,
+    description: string,
+    endTime: EpochTimeStamp,
+    method: string,
+    args: any[] = []
+  ) {
+    if (!this.#canVote()) throw new Error(`Not allowed to create a vote`)
+    const id = crypto.randomUUID()
+    this.#votes[id] = {
+      title,
+      description,
+      method,
+      endTime,
+      args
+    }
+  }
+
+  #canVote() {
+    // @ts-expect-error
+    return this._canVote?.()
+  }
+
+  #beforeVote() {
+    // @ts-expect-error
+    return this._beforeVote?.()
+  }
+
+  #endVoting(voteId) {
+    let agree = Object.values(this.#votes[voteId].results).filter(
+      (result) => result === 1
+    )
+    let disagree = Object.values(this.#votes[voteId].results).filter(
+      (result) => result === 0
+    )
+    if (agree.length > disagree.length && this.#votes[voteId].enoughVotes)
+      this[this.#votes[voteId].method](...this.#votes[voteId].args)
+    this.#votes[voteId].finished = true
+  }
+
+  async vote(voteId: string, vote: VoteResult) {
+    vote = Number(vote) as VoteResult
+    if (vote !== 0 && vote !== 0.5 && vote !== 1)
+      throw new Error(`invalid vote value ${vote}`)
+    if (!this.#votes[voteId]) throw new Error(`Nothing found for ${voteId}`)
+    const ended = new Date().getTime() > this.#votes[voteId].endTime
+    if (ended && !this.#votes[voteId].finished) this.#endVoting(voteId)
+    if (ended) throw new Error('voting already ended')
+    if (!this.#canVote()) throw new Error(`Not allowed to vote`)
+    await this.#beforeVote()
+    this.#votes[voteId][msg.sender] = vote
+  }
+
+  #disableVoting() {
+    this.#votingDisabled = true
+  }
+
+  disableVoting() {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    else {
+      this.createVote(
+        `disable voting`,
+        `Warning this disables all voting features forever`,
+        new Date().getTime() + this.#votingDuration,
+        '#disableVoting',
+        []
+      )
+    }
+  }
+
+  _sync() {
+    for (const vote of this.inProgress) {
+      if (vote.endTime < new Date().getTime()) this.#endVoting(vote.id)
+    }
+  }
+}

package/src/voting/types.ts

@@ -1,24 +1,30 @@
-export type VoteResult = 0 | 0.5 | 1
-
-export type Vote = {
-  title: string
-  method: string
-  args: any[]
-  description: string
-  endTime: EpochTimeStamp
-  results?: { [address: string]: VoteResult }
-  finished?: boolean
-  enoughVotes?: boolean
-}
-
-export interface VotingState {
-  votes: {
-    [id: string]: Vote
-  }
-  votingDisabled: boolean
-  votingDuration: number
-}
-
-export interface VoteView extends Vote {
-  id: string
-}
+import { MetaState } from '../types.js'
+
+export interface VotingState extends MetaState {
+  votes: {
+    [id: string]: Vote
+  }
+  votingDisabled: boolean
+  votingDuration: number
+}
+
+export interface PrivateVotingState extends VotingState {
+  voters: address[]
+}
+
+export type VoteResult = 0 | 0.5 | 1
+
+export type Vote = {
+  title: string
+  method: string
+  args: any[]
+  description: string
+  endTime: EpochTimeStamp
+  results?: { [address: string]: VoteResult }
+  finished?: boolean
+  enoughVotes?: boolean
+}
+
+export interface VoteView extends Vote {
+  id: string
+}

package/test/helpers.js

@@ -0,0 +1,51 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { restoreBalances, restoreApprovals } from './../exports/helpers.js'
+
+test('Helpers - restoreBalances converts string balances to BigInt', () => {
+  const balances = {
+    '0x1': '1000',
+    '0x2': '2000',
+    '0x3': '5000'
+  }
+
+  const restored = restoreBalances(balances)
+
+  assert.equal(restored['0x1'], 1000n)
+  assert.equal(restored['0x2'], 2000n)
+  assert.equal(restored['0x3'], 5000n)
+})
+
+test('Helpers - restoreBalances handles empty balances', () => {
+  const balances = {}
+
+  const restored = restoreBalances(balances)
+
+  assert.deepEqual(restored, {})
+})
+
+test('Helpers - restoreApprovals converts nested string approvals to BigInt', () => {
+  const approvals = {
+    '0x1': {
+      '0x2': '500',
+      '0x3': '1000'
+    },
+    '0x2': {
+      '0x3': '250'
+    }
+  }
+
+  const restored = restoreApprovals(approvals)
+
+  assert.equal(restored['0x1']['0x2'], 500n)
+  assert.equal(restored['0x1']['0x3'], 1000n)
+  assert.equal(restored['0x2']['0x3'], 250n)
+})
+
+test('Helpers - restoreApprovals handles empty approvals', () => {
+  const approvals = {}
+
+  const restored = restoreApprovals(approvals)
+
+  assert.deepEqual(restored, {})
+})

package/test/public-voting.js

@@ -1,6 +1,365 @@
-import Voting from './../exports/public-voting.js'
-
-const voting = new Voting('0x0', '1000')
-
-console.log(voting)
-console.log(voting.votingDuration)
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import Voting from './../exports/public-voting.js'
+
+test('PublicVoting - constructor initializes with correct state', () => {
+  const state = {
+    votes: {},
+    votingDisabled: false,
+    votingDuration: 172800000
+  }
+  const voting = new Voting(state)
+
+  assert.deepEqual(voting.votes, {})
+  assert.equal(voting.votingDisabled, false)
+  assert.equal(voting.votingDuration, 172800000)
+})
+
+test('PublicVoting - votingDuration getter returns correct value', () => {
+  const state = {
+    votes: {},
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  assert.equal(voting.votingDuration, 172800000)
+})
+
+test('PublicVoting - votingDisabled getter returns correct value', () => {
+  const state = {
+    votes: {},
+    votingDisabled: true
+  }
+  const voting = new Voting(state)
+
+  assert.equal(voting.votingDisabled, true)
+})
+
+test('PublicVoting - inProgress returns empty array when no votes', () => {
+  const state = {
+    votes: {},
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  assert.deepEqual(voting.inProgress, [])
+})
+
+test('PublicVoting - votes getter returns existing votes', () => {
+  const voteId = '123e4567-e89b-12d3-a456-426614174000'
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [voteId]: {
+        title: 'Test Vote',
+        description: 'A test vote',
+        method: 'testMethod',
+        endTime: Date.now() + 100000,
+        args: [],
+        results: {},
+        finished: false
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+  const votes = voting.votes
+
+  assert.equal(Object.keys(votes).length, 1)
+  assert.equal(votes[voteId].title, 'Test Vote')
+  assert.equal(votes[voteId].description, 'A test vote')
+  assert.equal(votes[voteId].method, 'testMethod')
+})
+
+test('PublicVoting - inProgress returns only unfinished votes', () => {
+  const activeVoteId = '123e4567-e89b-12d3-a456-426614174000'
+  const finishedVoteId = '987e6543-e21b-12d3-a456-426614174001'
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [activeVoteId]: {
+        title: 'Active Vote',
+        description: 'An active vote',
+        method: 'testMethod',
+        endTime: Date.now() + 100000,
+        args: [],
+        finished: false
+      },
+      [finishedVoteId]: {
+        title: 'Finished Vote',
+        description: 'A finished vote',
+        method: 'testMethod',
+        endTime: Date.now() - 100000,
+        args: [],
+        finished: true
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+  const inProgress = voting.inProgress
+
+  assert.equal(inProgress.length, 1)
+  assert.equal(inProgress[0].title, 'Active Vote')
+  assert.equal(inProgress[0].id, activeVoteId)
+})
+
+test('PublicVoting - vote throws error for invalid vote value', async () => {
+  const voteId = '123e4567-e89b-12d3-a456-426614174000'
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [voteId]: {
+        title: 'Test Vote',
+        description: 'A test vote',
+        method: 'testMethod',
+        endTime: Date.now() + 100000,
+        args: [],
+        results: {},
+        finished: false
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  await assert.rejects(async () => voting.vote(voteId, 2), /invalid vote value/)
+})
+
+test('PublicVoting - vote throws error for non-existent vote', async () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {},
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  await assert.rejects(
+    async () => voting.vote('non-existent-id', 1),
+    /Nothing found for/
+  )
+})
+
+test('PublicVoting - vote throws error for ended vote', async () => {
+  const voteId = '123e4567-e89b-12d3-a456-426614174000'
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [voteId]: {
+        title: 'Expired Vote',
+        description: 'An expired vote',
+        method: 'testMethod',
+        endTime: Date.now() - 100000, // Already ended
+        args: [],
+        results: {},
+        finished: false
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  await assert.rejects(
+    async () => voting.vote(voteId, 1),
+    /voting already ended/
+  )
+})
+
+test('PublicVoting - vote ending marks vote as finished when time expires', () => {
+  const voteId = '123e4567-e89b-12d3-a456-426614174000'
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [voteId]: {
+        title: 'Expired Vote',
+        description: 'A vote that should end',
+        method: 'testMethod',
+        endTime: Date.now() - 100000, // Already ended
+        args: [],
+        results: {
+          '0x1': 0, // disagree
+          '0x2': 0, // disagree
+          '0x3': 1 // agree
+        },
+        finished: false,
+        enoughVotes: true
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  // Before sync, should be in progress
+  assert.equal(voting.inProgress.length, 1)
+
+  // Run sync to end expired vote
+  voting._sync()
+
+  // After sync, should not be in progress anymore
+  assert.equal(voting.inProgress.length, 0)
+})
+
+test('PublicVoting - _sync ends all expired in-progress votes', () => {
+  const expiredVoteId1 = '123e4567-e89b-12d3-a456-426614174000'
+  const expiredVoteId2 = '123e4567-e89b-12d3-a456-426614174001'
+  const activeVoteId = '123e4567-e89b-12d3-a456-426614174002'
+
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [expiredVoteId1]: {
+        title: 'Expired Vote 1',
+        description: 'First expired vote',
+        method: 'testMethod',
+        endTime: Date.now() - 50000,
+        args: [],
+        results: { '0x1': 1, '0x2': 0 },
+        finished: false
+      },
+      [expiredVoteId2]: {
+        title: 'Expired Vote 2',
+        description: 'Second expired vote',
+        method: 'testMethod',
+        endTime: Date.now() - 100000,
+        args: [],
+        results: { '0x1': 0, '0x2': 0 },
+        finished: false
+      },
+      [activeVoteId]: {
+        title: 'Active Vote',
+        description: 'Still active vote',
+        method: 'testMethod',
+        endTime: Date.now() + 100000,
+        args: [],
+        results: {},
+        finished: false
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  // Before sync, should have 3 in-progress votes
+  assert.equal(voting.inProgress.length, 3)
+
+  // Run sync to end expired votes
+  voting._sync()
+
+  // After sync, only the active vote should remain in progress
+  const inProgress = voting.inProgress
+  assert.equal(inProgress.length, 1)
+  assert.equal(inProgress[0].id, activeVoteId)
+
+  // Check that expired votes are marked as finished
+  const votes = voting.votes
+  assert.equal(votes[expiredVoteId1].finished, true)
+  assert.equal(votes[expiredVoteId2].finished, true)
+  assert.equal(votes[activeVoteId].finished, false)
+})
+
+test('PublicVoting - vote ending with more agrees than disagrees', () => {
+  const voteId = '123e4567-e89b-12d3-a456-426614174000'
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [voteId]: {
+        title: 'Vote with Majority Agree',
+        description: 'Should pass with majority',
+        method: 'testMethod',
+        endTime: Date.now() - 1000,
+        args: ['arg1', 'arg2'],
+        results: {
+          '0x1': 1, // agree
+          '0x2': 1, // agree
+          '0x3': 1, // agree
+          '0x4': 0, // disagree
+          '0x5': 0 // disagree
+        },
+        finished: false,
+        enoughVotes: false // Not enough votes to execute method
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  // Before sync, vote should be in progress
+  assert.equal(voting.inProgress.length, 1)
+
+  // Run sync to trigger vote ending
+  voting._sync()
+
+  // After sync, vote should not be in progress
+  assert.equal(voting.inProgress.length, 0)
+})
+
+test('PublicVoting - vote ending with more disagrees than agrees', async () => {
+  const voteId = '123e4567-e89b-12d3-a456-426614174000'
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [voteId]: {
+        title: 'Vote with Majority Disagree',
+        description: 'Should not pass',
+        method: 'testMethod',
+        endTime: Date.now() - 1000,
+        args: [],
+        results: {
+          '0x1': 0, // disagree
+          '0x2': 0, // disagree
+          '0x3': 0, // disagree
+          '0x4': 1, // agree
+          '0x5': 1 // agree
+        },
+        finished: false,
+        enoughVotes: true
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  // Trigger vote ending
+  try {
+    await voting.vote(voteId, 1)
+  } catch (err) {
+    // Expected to throw "voting already ended"
+  }
+
+  // Verify vote is finished even though it didn't pass
+  assert.equal(voting.votes[voteId].finished, true)
+})
+
+test('PublicVoting - vote ending without enoughVotes flag does not execute method', async () => {
+  const voteId = '123e4567-e89b-12d3-a456-426614174000'
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    votes: {
+      [voteId]: {
+        title: 'Vote Without Enough Votes',
+        description: 'Has majority but not enough votes',
+        method: 'testMethod',
+        endTime: Date.now() - 1000,
+        args: [],
+        results: {
+          '0x1': 1, // agree
+          '0x2': 0 // disagree
+        },
+        finished: false,
+        enoughVotes: false // Not enough votes to execute
+      }
+    },
+    votingDisabled: false
+  }
+  const voting = new Voting(state)
+
+  // Trigger vote ending
+  try {
+    await voting.vote(voteId, 1)
+  } catch (err) {
+    // Expected to throw "voting already ended"
+  }
+
+  // Vote should be marked as finished
+  assert.equal(voting.votes[voteId].finished, true)
+})