@leofcoin/standards 0.2.7 → 0.2.8

package/exports/voting-xYjJlN2h.js

@@ -0,0 +1,112 @@
+import ContractCreator from './contract-creator.js';
+
+class Voting extends ContractCreator {
+    #votes = {};
+    #votingDisabled = false;
+    #votingDuration = 172800000;
+    constructor(state) {
+        super(state);
+        if (state) {
+            this.#votes = state.votes;
+            this.#votingDisabled = state.votingDisabled;
+            this.#votingDuration = state.votingDuration;
+        }
+    }
+    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
+        };
+    }
+    #canVote() {
+        // @ts-expect-error
+        return this._canVote?.();
+    }
+    #beforeVote() {
+        // @ts-expect-error
+        return this._beforeVote?.();
+    }
+    #afterVote() {
+        // @ts-expect-error
+        return this._afterVote?.();
+    }
+    /**
+     * create vote
+     * @param {string} vote
+     * @param {string} description
+     * @param {number} endTime
+     * @param {string} method function to run when agree amount is bigger
+     */
+    createVote(title, description, endTime, method, args = []) {
+        if (!this.#canVote())
+            throw new Error(`Not allowed to create a vote`);
+        const id = crypto.randomUUID();
+        this.#votes[id] = {
+            title,
+            description,
+            method,
+            endTime,
+            args
+        };
+    }
+    #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[this.#votes[voteId].method](...this.#votes[voteId].args);
+        this.#votes[voteId].finished = true;
+    }
+    async vote(voteId, vote) {
+        vote = Number(vote);
+        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;
+        await this.#afterVote();
+    }
+    get votesInProgress() {
+        return Object.entries(this.#votes)
+            .filter(([id, vote]) => !vote.finished)
+            .map(([id, vote]) => {
+            return { ...vote, id };
+        });
+    }
+    #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.votesInProgress) {
+            if (vote.endTime < new Date().getTime())
+                this.#endVoting(vote.id);
+        }
+    }
+}
+
+export { Voting as V };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/standards",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Contract standards",
   "type": "module",
   "exports": {

package/src/decorators/time.ts

@@ -2,7 +2,7 @@ export function time(target, descriptor) {
   console.log({ descriptor }, { target })
   if (descriptor.kind !== 'method') throw new Error(`expected ${descriptor.name} to be a method`)
   descriptor.addInitializer(function () {
-    pubsub.subscribe('time-interval', (value) => {
+    globalThis.pubsub.subscribe('time-interval', (value) => {
       this.onTimeChange?.(value)
     })
   })

package/src/lock.ts

@@ -0,0 +1,166 @@
+import { restoreApprovals, restoreBalances } from './helpers.js'
+import Roles, { RolesState } from './roles.js'
+
+export declare interface LockState extends RolesState {
+  holders: BigNumberish
+  balances: { [address: address]: BigNumberish }
+  totalSupply: BigNumberish
+}
+
+export default class Lock extends PublicVoting {
+  /**
+   * string
+   */
+  #name: string
+  /**
+   * String
+   */
+  #symbol: string
+  /**
+   * uint
+   */
+  #holders: typeof BigNumber = BigNumber['from'](0)
+  /**
+   * Object => Object => uint
+   */
+  #balances = {}
+  /**
+   * Object => Object => uint
+   */
+  #approvals: { [owner: string]: { [operator: string]: typeof BigNumber } } = {}
+
+  #decimals = 18
+
+  #totalSupply: typeof BigNumber = BigNumber['from'](0)
+
+  #stakingContract: address
+
+  // this.#privateField2 = 1
+  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 = BigNumber['from'](state.holders)
+      this.#totalSupply = BigNumber['from'](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(): TokenState {
+    return {
+      ...super.state,
+      holders: this.holders,
+      balances: this.balances,
+      approvals: { ...this.#approvals },
+      totalSupply: this.totalSupply
+    }
+  }
+
+  get totalSupply(): BigNumberish {
+    return this.#totalSupply
+  }
+
+  get name(): string {
+    return this.#name
+  }
+
+  get symbol(): string {
+    return this.#symbol
+  }
+
+  get holders(): TokenState['holders'] {
+    return this.#holders
+  }
+
+  get balances(): TokenState['balances'] {
+    return { ...this.#balances }
+  }
+
+  get approvals() {
+    return this.#approvals
+  }
+
+  get decimals() {
+    return this.#decimals
+  }
+
+  mint(to: address, amount: BigNumberish) {
+    if (!this.hasRole(msg.sender, 'MINT')) throw new Error('not allowed')
+
+    this.#totalSupply = this.#totalSupply.add(amount)
+    this.#increaseBalance(to, amount)
+  }
+
+  burn(from: address, amount: BigNumberish) {
+    if (!this.hasRole(msg.sender, 'BURN') || msg.sender !== from) throw new Error('not allowed')
+    const total = this.#totalSupply.sub(amount)
+    if (total.gte(0)) {
+      this.#totalSupply = total
+      this.#decreaseBalance(from, amount)
+    }
+  }
+
+  #beforeTransfer(from: address, to: address, amount: BigNumberish) {
+    if (!this.#balances[from] || this.#balances[from] < amount) throw new Error('amount exceeds balance')
+  }
+
+  #updateHolders(address: address, previousBalance: typeof BigNumber) {
+    if (this.#balances[address].toHexString() === '0x00') this.#holders.sub(1)
+    else if (this.#balances[address].toHexString() !== '0x00' && previousBalance.toHexString() === '0x00')
+      this.#holders.add(1)
+  }
+
+  #increaseBalance(address: address, amount: BigNumberish) {
+    if (!this.#balances[address]) this.#balances[address] = BigNumber['from'](0)
+    const previousBalance = this.#balances[address]
+
+    this.#balances[address] = this.#balances[address].add(amount)
+    this.#updateHolders(address, previousBalance)
+  }
+
+  #decreaseBalance(address: address, amount: BigNumberish) {
+    const previousBalance = this.#balances[address]
+    this.#balances[address] = this.#balances[address].sub(amount)
+    this.#updateHolders(address, previousBalance)
+  }
+
+  balance() {
+    return this.#balances[msg.sender]
+  }
+
+  balanceOf(address: address): BigNumberish {
+    return this.#balances[address]
+  }
+
+  setApproval(operator: address, amount: BigNumberish) {
+    const owner = msg.sender
+    if (!this.#approvals[owner]) this.#approvals[owner] = {}
+    this.#approvals[owner][operator] = BigNumber['from'](amount)
+  }
+
+  approved(owner: address, operator: address, amount: BigNumberish): boolean {
+    return this.#approvals[owner][operator] === amount
+  }
+
+  transfer(from: address, to: address, amount: BigNumberish) {
+    // TODO: is BigNumber?
+    amount = BigNumber['from'](amount)
+    this.#beforeTransfer(from, to, amount)
+    this.#decreaseBalance(from, amount)
+    this.#increaseBalance(to, amount)
+  }
+}

package/src/staking.ts

@@ -0,0 +1,165 @@
+import { restoreApprovals, restoreBalances } from './helpers.js'
+import Roles, { RolesState } from './roles.js'
+
+export declare interface TokenState extends RolesState {
+  holders: BigNumberish
+  balances: { [address: address]: BigNumberish }
+  approvals: { [owner: address]: { [operator: address]: BigNumberish } }
+  totalSupply: BigNumberish
+}
+
+export default class Token extends Roles {
+  /**
+   * string
+   */
+  #name: string
+  /**
+   * String
+   */
+  #symbol: string
+  /**
+   * uint
+   */
+  #holders: typeof BigNumber = BigNumber['from'](0)
+  /**
+   * Object => Object => uint
+   */
+  #balances = {}
+  /**
+   * Object => Object => uint
+   */
+  #approvals: { [owner: string]: { [operator: string]: typeof BigNumber } } = {}
+
+  #decimals = 18
+
+  #totalSupply: typeof BigNumber = BigNumber['from'](0)
+
+  // this.#privateField2 = 1
+  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 = BigNumber['from'](state.holders)
+      this.#totalSupply = BigNumber['from'](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(): TokenState {
+    return {
+      ...super.state,
+      holders: this.holders,
+      balances: this.balances,
+      approvals: { ...this.#approvals },
+      totalSupply: this.totalSupply
+    }
+  }
+
+  get totalSupply(): BigNumberish {
+    return this.#totalSupply
+  }
+
+  get name(): string {
+    return this.#name
+  }
+
+  get symbol(): string {
+    return this.#symbol
+  }
+
+  get holders(): TokenState['holders'] {
+    return this.#holders
+  }
+
+  get balances(): TokenState['balances'] {
+    return { ...this.#balances }
+  }
+
+  get approvals() {
+    return this.#approvals
+  }
+
+  get decimals() {
+    return this.#decimals
+  }
+
+  mint(to: address, amount: BigNumberish) {
+    if (!this.hasRole(msg.sender, 'MINT')) throw new Error('not allowed')
+
+    this.#totalSupply = this.#totalSupply.add(amount)
+    this.#increaseBalance(to, amount)
+  }
+
+  burn(from: address, amount: BigNumberish) {
+    if (!this.hasRole(msg.sender, 'BURN') || msg.sender !== from) throw new Error('not allowed')
+    const total = this.#totalSupply.sub(amount)
+    if (total.gte(0)) {
+      this.#totalSupply = total
+      this.#decreaseBalance(from, amount)
+    }
+  }
+
+  #beforeTransfer(from: address, to: address, amount: BigNumberish) {
+    if (!this.#balances[from] || this.#balances[from] < amount) throw new Error('amount exceeds balance')
+  }
+
+  #updateHolders(address: address, previousBalance: typeof BigNumber) {
+    if (this.#balances[address].toHexString() === '0x00') this.#holders.sub(1)
+    else if (this.#balances[address].toHexString() !== '0x00' && previousBalance.toHexString() === '0x00')
+      this.#holders.add(1)
+  }
+
+  #increaseBalance(address: address, amount: BigNumberish) {
+    if (!this.#balances[address]) this.#balances[address] = BigNumber['from'](0)
+    const previousBalance = this.#balances[address]
+
+    this.#balances[address] = this.#balances[address].add(amount)
+    this.#updateHolders(address, previousBalance)
+  }
+
+  #decreaseBalance(address: address, amount: BigNumberish) {
+    const previousBalance = this.#balances[address]
+    this.#balances[address] = this.#balances[address].sub(amount)
+    this.#updateHolders(address, previousBalance)
+  }
+
+  balance() {
+    return this.#balances[msg.sender]
+  }
+
+  balanceOf(address: address): BigNumberish {
+    return this.#balances[address]
+  }
+
+  setApproval(operator: address, amount: BigNumberish) {
+    const owner = msg.sender
+    if (!this.#approvals[owner]) this.#approvals[owner] = {}
+    this.#approvals[owner][operator] = BigNumber['from'](amount)
+  }
+
+  approved(owner: address, operator: address, amount: BigNumberish): boolean {
+    return this.#approvals[owner][operator] === amount
+  }
+
+  transfer(from: address, to: address, amount: BigNumberish) {
+    // TODO: is BigNumber?
+    amount = BigNumber['from'](amount)
+    this.#beforeTransfer(from, to, amount)
+    this.#decreaseBalance(from, amount)
+    this.#increaseBalance(to, amount)
+  }
+}

package/src/token-receiver.ts

@@ -1,4 +1,4 @@
-import { IPublicVoting } from './voting/interfaces/i-public-voting.js'
+import { IVoting } from './voting/interfaces/i-voting.js'
 import PublicVoting, { PublicVotingState } from './voting/public-voting.js'
 
 export interface TokenReceiverState extends PublicVotingState {
@@ -7,7 +7,7 @@ export interface TokenReceiverState extends PublicVotingState {
   tokenAmountToReceive: typeof BigNumber
   voteType: 'burn' | 'transfer'
 }
-export default class TokenReceiver extends PublicVoting implements IPublicVoting {
+export default class TokenReceiver extends PublicVoting implements IVoting {
   #tokenToReceive: address
   #tokenAmountToReceive: typeof BigNumber
   #tokenReceiver: address
@@ -74,7 +74,7 @@ export default class TokenReceiver extends PublicVoting implements IPublicVoting
   }
 
   async _beforeVote(): Promise<any> {
-    await this.#beforeVote()
+    return this.#beforeVote()
   }
 
   /**

package/src/token.ts

@@ -2,6 +2,9 @@ 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: BigNumberish
   balances: { [address: address]: BigNumberish }
   approvals: { [owner: address]: { [operator: address]: BigNumberish } }
@@ -34,6 +37,8 @@ export default class Token extends Roles {
 
   #totalSupply: typeof BigNumber = BigNumber['from'](0)
 
+  #stakingContract: address
+
   // this.#privateField2 = 1
   constructor(name: string, symbol: string, decimals: number = 18, state?: TokenState) {
     if (!name) throw new Error(`name undefined`)
@@ -46,6 +51,9 @@ export default class Token extends Roles {
       this.#approvals = restoreApprovals(state.approvals)
       this.#holders = BigNumber['from'](state.holders)
       this.#totalSupply = BigNumber['from'](state.totalSupply)
+      this.#name = name
+      this.#symbol = symbol
+      this.#decimals = decimals
     } else {
       this.#name = name
       this.#symbol = symbol
@@ -62,6 +70,9 @@ export default class Token extends Roles {
   get state(): TokenState {
     return {
       ...super.state,
+      name: this.#name,
+      symbol: this.#symbol,
+      decimals: this.#decimals,
       holders: this.holders,
       balances: this.balances,
       approvals: { ...this.#approvals },
@@ -105,10 +116,12 @@ export default class Token extends Roles {
   }
 
   burn(from: address, amount: BigNumberish) {
-    if (!this.hasRole(msg.sender, 'BURN')) throw new Error('not allowed')
-
-    this.#totalSupply = this.#totalSupply.sub(amount)
-    this.#decreaseBalance(from, amount)
+    if (!this.hasRole(msg.sender, 'BURN') || msg.sender !== from) throw new Error('not allowed')
+    const total = this.#totalSupply.sub(amount)
+    if (total.gte(0)) {
+      this.#totalSupply = total
+      this.#decreaseBalance(from, amount)
+    }
   }
 
   #beforeTransfer(from: address, to: address, amount: BigNumberish) {

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

@@ -0,0 +1,5 @@
+export interface IVoting {
+  _canVote?(): Promise<boolean> | boolean
+  _beforeVote?(): Promise<void> | void
+  _afterVote?(): Promise<void> | void
+}