@leofcoin/standards 0.2.15 → 0.3.0

package/src/token.ts

@@ -1,198 +1,162 @@
-import { restoreApprovals, restoreBalances } from './helpers.js'
-import Roles, { RolesState } from './roles.js'
-
-export declare interface TokenState extends RolesState {
-  name: string
-  symbol: string
-  decimals: number
-  holders: bigint
-  balances: { [address: address]: bigint }
-  approvals: { [owner: address]: { [operator: address]: bigint } }
-  totalSupply: bigint
-  maxSupply: bigint // 0 for unlimited
-}
-
-export default class Token extends Roles {
-  /**
-   * string
-   */
-  #name: string
-  /**
-   * String
-   */
-  #symbol: string
-  /**
-   * uint
-   */
-  #holders: bigint = BigInt(0)
-  /**
-   * Object => Object => uint
-   */
-  #balances = {}
-  /**
-   * Object => Object => uint
-   */
-  #approvals: { [owner: string]: { [operator: string]: bigint } } = {}
-
-  #decimals = 18
-
-  #totalSupply: bigint = BigInt(0)
-
-  #maxSupply: bigint = BigInt(0)
-
-  #stakingContract: address
-
-  constructor(name: string, symbol: string, decimals: number = 18, state?: TokenState) {
-    if (!name) throw new Error(`name undefined`)
-    if (!symbol) throw new Error(`symbol undefined`)
-
-    super(state)
-
-    if (state) {
-      this.#balances = restoreBalances(state.balances)
-      this.#approvals = restoreApprovals(state.approvals)
-      this.#holders = BigInt(state.holders)
-      this.#totalSupply = BigInt(state.totalSupply)
-      this.#name = name
-      this.#symbol = symbol
-      this.#decimals = decimals
-      this.#maxSupply = BigInt(state.maxSupply)
-    } else {
-      this.#name = name
-      this.#symbol = symbol
-      this.#decimals = decimals
-    }
-  }
-
-  // enables snapshotting
-  // needs dev attention so nothing breaks after snapshot happens
-  // iow everything that is not static needs to be included in the stateObject
-  // TODO: implement snapshotting test
-  /**
-   * @return {Object} {holders, balances, ...}
-   */
-  get state(): TokenState {
-    return {
-      ...super.state,
-      name: this.#name,
-      symbol: this.#symbol,
-      decimals: this.#decimals,
-      holders: this.holders,
-      balances: this.balances,
-      approvals: { ...this.#approvals },
-      totalSupply: this.totalSupply,
-      maxSupply: this.#maxSupply
-    }
-  }
-
-  get maxSupply(): TokenState['maxSupply'] {
-    return this.#maxSupply
-  }
-
-  get totalSupply(): TokenState['totalSupply'] {
-    return this.#totalSupply
-  }
-
-  get name(): TokenState['name'] {
-    return this.#name
-  }
-
-  get symbol(): TokenState['symbol'] {
-    return this.#symbol
-  }
-
-  get holders(): TokenState['holders'] {
-    return this.#holders
-  }
-
-  get balances(): TokenState['balances'] {
-    return { ...this.#balances }
-  }
-
-  get approvals(): TokenState['approvals'] {
-    return this.#approvals
-  }
-
-  get decimals(): TokenState['decimals'] {
-    return this.#decimals
-  }
-
-  mint(to: address, amount: bigint) {
-    if (!this.hasRole(msg.sender, 'MINT')) throw new Error('mint role required')
-
-    const supply = this.#totalSupply + amount
-    if (this.#maxSupply === 0n) {
-      this.#totalSupply = supply
-      this.#increaseBalance(to, amount)
-    } else {
-      if (supply <= this.#maxSupply) {
-        this.#totalSupply = supply
-        this.#increaseBalance(to, amount)
-      } else {
-        throw new Error('amount exceeds max supply')
-      }
-    }
-  }
-
-  burn(from: address, amount: bigint) {
-    if (!this.hasRole(msg.sender, 'BURN') && msg.sender !== from) throw new Error('not the owner or burn role required')
-    if (this.#balances[from] < amount) throw new Error('amount exceeds balance')
-
-    const total = this.#totalSupply - amount
-    if (total >= 0) {
-      this.#totalSupply = total
-      this.#decreaseBalance(from, amount)
-    } else {
-      throw new Error('amount exceeds total supply')
-    }
-  }
-
-  #beforeTransfer(from: address, to: address, amount: bigint) {
-    if (!this.#balances[from] || this.#balances[from] < amount) throw new Error('amount exceeds balance')
-  }
-
-  #updateHolders(address: address, previousBalance: bigint) {
-    if (this.#balances[address] === 0n) this.#holders -= 1n
-    else if (this.#balances[address] !== 0n && previousBalance === 0n) this.#holders += 1n
-  }
-
-  #increaseBalance(address: address, amount: bigint) {
-    if (!this.#balances[address]) this.#balances[address] = BigInt(0)
-    const previousBalance = this.#balances[address]
-
-    this.#balances[address] = this.#balances[address] += amount
-    this.#updateHolders(address, previousBalance)
-  }
-
-  #decreaseBalance(address: address, amount: bigint) {
-    const previousBalance = this.#balances[address]
-    this.#balances[address] = this.#balances[address] -= amount
-    this.#updateHolders(address, previousBalance)
-  }
-
-  balance() {
-    return this.#balances[msg.sender]
-  }
-
-  balanceOf(address: address): bigint {
-    return this.#balances[address]
-  }
-
-  setApproval(operator: address, amount: bigint) {
-    const owner = msg.sender
-    if (!this.#approvals[owner]) this.#approvals[owner] = {}
-    this.#approvals[owner][operator] = BigInt(amount)
-  }
-
-  approved(owner: address, operator: address, amount: bigint): boolean {
-    return this.#approvals[owner][operator] === amount
-  }
-
-  transfer(from: address, to: address, amount: bigint) {
-    // TODO: is bigint?
-    amount = BigInt(amount)
-    this.#beforeTransfer(from, to, amount)
-    this.#decreaseBalance(from, amount)
-    this.#increaseBalance(to, amount)
-  }
-}
+import { restoreApprovals, restoreBalances } from './helpers.js'
+import Roles from './roles.js'
+import { TokenState } from './types.js'
+
+export default class Token extends Roles {
+  /**
+   * string
+   */
+  #name: string
+  /**
+   * String
+   */
+  #symbol: string
+  /**
+   * uint
+   */
+  #holders: bigint = 0n
+  /**
+   * Object => Object => uint
+   */
+  #balances = {}
+  /**
+   * Object => Object => uint
+   */
+  #approvals: { [owner: string]: { [operator: string]: bigint } } = {}
+
+  #decimals = 18
+
+  #totalSupply: bigint = 0n
+
+  constructor(
+    name: string,
+    symbol: string,
+    decimals: number = 18,
+    state?: TokenState
+  ) {
+    if (!name) throw new Error(`name undefined`)
+    if (!symbol) throw new Error(`symbol undefined`)
+
+    super(state)
+
+    if (state) {
+      this.#balances = restoreBalances(state.balances)
+      this.#approvals = restoreApprovals(state.approvals)
+      this.#holders = BigInt(state.holders)
+      this.#totalSupply = BigInt(state.totalSupply)
+    } else {
+      this.#name = name
+      this.#symbol = symbol
+      this.#decimals = decimals
+    }
+  }
+
+  // enables snapshotting
+  // needs dev attention so nothing breaks after snapshot happens
+  // iow everything that is not static needs to be included in the stateObject
+  /**
+   * @return {Object} {holders, balances, ...}
+   */
+  get state(): {} {
+    return {
+      ...super.state,
+      holders: this.holders,
+      balances: this.balances,
+      approvals: { ...this.#approvals },
+      totalSupply: this.totalSupply
+    }
+  }
+
+  get totalSupply(): bigint {
+    return this.#totalSupply
+  }
+
+  get name(): string {
+    return this.#name
+  }
+
+  get symbol(): string {
+    return this.#symbol
+  }
+
+  get holders(): {} {
+    return this.#holders
+  }
+
+  get balances(): {} {
+    return { ...this.#balances }
+  }
+
+  get approvals() {
+    return this.#approvals
+  }
+
+  get decimals() {
+    return this.#decimals
+  }
+
+  mint(to: address, amount: bigint) {
+    if (!this.hasRole(msg.sender, 'MINT')) throw new Error('not allowed')
+
+    this.#totalSupply = this.#totalSupply + amount
+    this.#increaseBalance(to, amount)
+  }
+
+  burn(from: address, amount: bigint) {
+    if (!this.hasRole(msg.sender, 'BURN')) throw new Error('not allowed')
+
+    this.#totalSupply = this.#totalSupply - amount
+    this.#decreaseBalance(from, amount)
+  }
+
+  #beforeTransfer(from: address, to: address, amount: bigint) {
+    if (!this.#balances[from] || this.#balances[from] < amount)
+      throw new Error('amount exceeds balance')
+  }
+
+  #updateHolders(address: address, previousBalance: bigint) {
+    if (this.#balances[address] === 0n) this.#holders -= 1n
+    else if (this.#balances[address] !== 0n && previousBalance === 0n)
+      this.#holders += 1n
+  }
+
+  #increaseBalance(address: address, amount: bigint) {
+    if (!this.#balances[address]) this.#balances[address] = 0n
+    const previousBalance = this.#balances[address]
+
+    this.#balances[address] = this.#balances[address] + amount
+    this.#updateHolders(address, previousBalance)
+  }
+
+  #decreaseBalance(address: address, amount: bigint) {
+    const previousBalance = this.#balances[address]
+    this.#balances[address] = this.#balances[address] - amount
+    this.#updateHolders(address, previousBalance)
+  }
+
+  balance() {
+    return this.#balances[msg.sender]
+  }
+
+  balanceOf(address: address): bigint {
+    return this.#balances[address]
+  }
+
+  setApproval(operator: address, amount: bigint) {
+    const owner = msg.sender
+    if (!this.#approvals[owner]) this.#approvals[owner] = {}
+    this.#approvals[owner][operator] = BigInt(amount)
+  }
+
+  approved(owner: address, operator: address, amount: bigint): boolean {
+    return this.#approvals[owner][operator] === amount
+  }
+
+  transfer(from: address, to: address, amount: bigint) {
+    // TODO: is bigint?
+    amount = BigInt(amount)
+    this.#beforeTransfer(from, to, amount)
+    this.#decreaseBalance(from, amount)
+    this.#increaseBalance(to, amount)
+  }
+}

package/src/types.ts

@@ -0,0 +1,15 @@
+export interface MetaState {
+  creator: address
+  createdAt: bigint
+}
+
+export declare interface RolesState extends MetaState {
+  roles: { [index: string]: address[] }
+}
+
+export declare interface TokenState extends RolesState {
+  holders: bigint
+  balances: { [address: address]: bigint }
+  approvals: { [owner: address]: { [operator: address]: bigint } }
+  totalSupply: bigint
+}

package/src/voting/interfaces/i-public-voting.ts

@@ -0,0 +1,4 @@
+export interface IPublicVoting {
+  _canVote(): Promise<any>
+  _beforeVote(): Promise<any>
+}

package/src/voting/private-voting.ts

@@ -1,69 +1,187 @@
-import ContractCreator, { ContractCreatorState } from '../contract-creator.js'
-import { IVoting } from './interfaces/i-voting.js'
-import { VoteResult, VoteView, VotingState } from './types.js'
-import Voting from './voting.js'
-
-export interface PrivateVotingState extends VotingState, ContractCreatorState {
-  voters: address[]
-}
-
-export default class PrivateVoting extends Voting implements IVoting {
-  #voters: PrivateVotingState['voters']
-
-  constructor(state: PrivateVotingState) {
-    super(state)
-    if (state) {
-      this.#voters = state.voters
-    } else {
-      this.#voters = [msg.sender]
-    }
-  }
-
-  get state(): PrivateVotingState {
-    return {
-      ...super.state,
-      voters: this.#voters
-    }
-  }
-
-  _canVote(): boolean {
-    return this.#voters.includes(msg.sender)
-  }
-
-  #grantVotingPower(address) {
-    this.#voters.push(address)
-  }
-
-  #revokeVotingPower(address) {
-    this.#voters.splice(this.#voters.indexOf(address))
-  }
-
-  grantVotingPower(address: address, voteId: string) {
-    if (this.#voters.length === 1 && this._canVote()) this.#grantVotingPower(address)
-    else {
-      this.createVote(
-        `grant voting power to ${address}`,
-        `Should we grant ${address} voting power?`,
-        new Date().getTime() + this.votingDuration,
-        '#grantVotingPower',
-        [address]
-      )
-    }
-  }
-
-  revokeVotingPower(address: address, voteId: string) {
-    if (!this._canVote()) throw new Error('not a allowed to vote')
-    if (this.#voters.length === 1 && address === msg.sender && !this.votingDisabled)
-      throw new Error('only one voter left, disable voting before making this contract voteless')
-    if (this.#voters.length === 1) this.#revokeVotingPower(address)
-    else {
-      this.createVote(
-        `revoke voting power for ${address}`,
-        `Should we revoke ${address} it's voting power?`,
-        new Date().getTime() + this.votingDuration,
-        '#revokeVotingPower',
-        [address]
-      )
-    }
-  }
-}
+import Meta from '../meta.js'
+import {
+  PrivateVotingState,
+  VoteResult,
+  VoteView,
+  VotingState
+} from './types.js'
+
+export default class PrivateVoting extends Meta {
+  #voters: PrivateVotingState['voters']
+  #votes: PrivateVotingState['votes']
+  #votingDisabled: boolean
+
+  constructor(state: PrivateVotingState) {
+    super(state)
+    if (state) {
+      this.#voters = state.voters
+      this.#votes = state.votes
+      this.#votingDisabled = state.votingDisabled
+    } else {
+      this.#voters = [msg.sender]
+    }
+  }
+
+  get votes() {
+    return { ...this.#votes }
+  }
+
+  get voters() {
+    return { ...this.#voters }
+  }
+
+  get votingDisabled() {
+    return this.#votingDisabled
+  }
+
+  /**
+   *
+   */
+  get state(): {} {
+    return {
+      ...super.state,
+      voters: this.#voters,
+      votes: this.#votes,
+      votingDisabled: this.#votingDisabled
+    }
+  }
+
+  get inProgress(): VoteView[] {
+    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(msg.sender))
+      throw new Error(`Not allowed to create a vote`)
+    const id = crypto.randomUUID()
+    this.#votes[id] = {
+      title,
+      description,
+      method,
+      endTime,
+      args
+    }
+  }
+
+  canVote(address: address) {
+    return this.#voters.includes(address)
+  }
+
+  #enoughVotes(id) {
+    return this.#voters.length - 2 <= Object.keys(this.#votes[id]).length
+  }
+
+  #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
+    )
+    this.#votes[voteId].enoughVotes = this.#enoughVotes(voteId)
+    if (agree.length > disagree.length && this.#votes[voteId].enoughVotes)
+      this[this.#votes[voteId].method](...this.#votes[voteId].args)
+    this.#votes[voteId].finished = true
+  }
+
+  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(msg.sender)) throw new Error(`Not allowed to vote`)
+    this.#votes[voteId][msg.sender] = vote
+    if (this.#enoughVotes(voteId)) {
+      this.#endVoting(voteId)
+    }
+  }
+
+  #disableVoting() {
+    this.#votingDisabled = true
+    this.#voters = []
+  }
+
+  #grantVotingPower(address) {
+    this.#voters.push(address)
+  }
+
+  #revokeVotingPower(address) {
+    this.#voters.splice(this.#voters.indexOf(address))
+  }
+
+  disableVoting() {
+    if (!this.canVote(msg.sender)) throw new Error('not a allowed')
+    if (this.#voters.length === 1) this.#disableVoting()
+    else {
+      this.createVote(
+        `disable voting`,
+        `Warning this disables all voting features forever`,
+        new Date().getTime() + 172800000,
+        '#disableVoting',
+        []
+      )
+    }
+  }
+
+  grantVotingPower(address: address, voteId: string) {
+    if (this.#voters.length === 1 && this.canVote(msg.sender))
+      this.#grantVotingPower(address)
+    else {
+      this.createVote(
+        `grant voting power to ${address}`,
+        `Should we grant ${address} voting power?`,
+        new Date().getTime() + 172800000,
+        '#grantVotingPower',
+        [address]
+      )
+    }
+  }
+
+  revokeVotingPower(address: address, voteId: string) {
+    if (!this.canVote(msg.sender)) throw new Error('not a allowed to vote')
+    if (
+      this.#voters.length === 1 &&
+      address === msg.sender &&
+      !this.#votingDisabled
+    )
+      throw new Error(
+        'only one voter left, disable voting before making this contract voteless'
+      )
+    if (this.#voters.length === 1) this.#revokeVotingPower(address)
+    else {
+      this.createVote(
+        `revoke voting power for ${address}`,
+        `Should we revoke ${address} it's voting power?`,
+        new Date().getTime() + 172800000,
+        '#revokeVotingPower',
+        [address]
+      )
+    }
+  }
+
+  sync() {
+    for (const vote of this.inProgress) {
+      if (vote.endTime < new Date().getTime()) this.#endVoting(vote.id)
+    }
+  }
+}