@leofcoin/standards 0.1.5 → 0.1.7

package/exports/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const restoreBalances: (balances: any) => {};
+export declare const restoreApprovals: (approvals: any) => {};

package/exports/helpers.js

@@ -0,0 +1,20 @@
+// when state is stored it get encoded as a string to  so we need to reformat balances back to BigNumbers
+const restoreBalances = (balances) => {
+    const _balances = {};
+    for (const address in balances) {
+        _balances[address] = BigNumber['from'](balances[address]);
+    }
+    return _balances;
+};
+const restoreApprovals = (approvals) => {
+    const _approvals = {};
+    for (const owner in approvals) {
+        _approvals[owner] = {};
+        for (const operator in approvals[owner]) {
+            _approvals[owner][operator] = BigNumber['from'](approvals[owner][operator]);
+        }
+    }
+    return _approvals;
+};
+
+export { restoreApprovals, restoreBalances };

package/exports/index.d.ts

@@ -1,2 +1,4 @@
 export { default as Token } from './token.js';
 export { default as Roles } from './roles.js';
+export { default as Voting } from './voting.js';
+export * from './helpers.js';

package/exports/index.js

@@ -1,2 +1,4 @@
 export { default as Token } from './token.js';
 export { default as Roles } from './roles.js';
+export { default as Voting } from './voting.js';
+export { restoreApprovals, restoreBalances } from './helpers.js';

package/exports/token.d.ts

@@ -3,11 +3,15 @@ export declare type TokenState = {
     roles: {
         [index: string]: address[];
     };
-    holders: number;
+    holders: BigNumberish;
     balances: {
-        [index: string]: BigNumberish;
+        [address: address]: BigNumberish;
+    };
+    approvals: {
+        [owner: address]: {
+            [operator: address]: BigNumberish;
+        };
     };
-    approvals: {};
     totalSupply: BigNumberish;
 };
 export default class Token extends Roles {

package/exports/token.js

@@ -1,3 +1,4 @@
+import { restoreBalances, restoreApprovals } from './helpers.js';
 import Roles from './roles.js';
 
 class Token extends Roles {
@@ -31,9 +32,9 @@ class Token extends Roles {
             throw new Error(`symbol undefined`);
         super(state?.roles);
         if (state) {
+            this.#balances = restoreBalances(state.balances);
+            this.#approvals = restoreApprovals(state.approvals);
             this.#holders = BigNumber['from'](state.holders);
-            this.#balances = BigNumber['from'](state.balances);
-            this.#approvals = BigNumber['from'](state.approvals);
             this.#totalSupply = BigNumber['from'](state.totalSupply);
         }
         else {
@@ -116,7 +117,7 @@ class Token extends Roles {
         const owner = msg.sender;
         if (!this.#approvals[owner])
             this.#approvals[owner] = {};
-        this.#approvals[owner][operator] = amount;
+        this.#approvals[owner][operator] = BigNumber['from'](amount);
     }
     approved(owner, operator, amount) {
         return this.#approvals[owner][operator] === amount;

package/exports/voting.d.ts

@@ -0,0 +1,134 @@
+export type VoteResult = 0 | 0.5 | 1;
+export type Vote = {
+    title: string;
+    method: string;
+    args: any[];
+    description: string;
+    endTime: EpochTimeStamp;
+    results?: {
+        [address: address]: VoteResult;
+    };
+    finished?: boolean;
+    enoughVotes?: boolean;
+};
+export type VotingState = {
+    voters: address[];
+    votes: {
+        [id: string]: Vote;
+    };
+    votingDisabled: boolean;
+};
+export interface VoteView extends Vote {
+    id: string;
+}
+export default class Voting {
+    #private;
+    constructor(state: VotingState);
+    get votes(): {
+        [x: string]: Vote;
+    };
+    get voters(): {
+        [x: number]: string;
+        length: number;
+        toString(): string;
+        toLocaleString(): string;
+        pop(): string;
+        push(...items: string[]): number;
+        concat(...items: ConcatArray<string>[]): string[];
+        concat(...items: (string | ConcatArray<string>)[]): string[];
+        join(separator?: string): string;
+        reverse(): string[];
+        shift(): string;
+        slice(start?: number, end?: number): string[];
+        sort(compareFn?: (a: string, b: string) => number): string[];
+        splice(start: number, deleteCount?: number): string[];
+        splice(start: number, deleteCount: number, ...items: string[]): string[];
+        unshift(...items: string[]): number;
+        indexOf(searchElement: string, fromIndex?: number): number;
+        lastIndexOf(searchElement: string, fromIndex?: number): number;
+        every<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[];
+        filter<S_1 extends string>(predicate: (value: string, index: number, array: string[]) => value is S_1, thisArg?: any): S_1[];
+        filter(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[];
+        reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+        reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+        reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: string, currentIndex: number, array: string[]) => U_1, initialValue: U_1): U_1;
+        reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+        reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+        reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: string, currentIndex: number, array: string[]) => U_2, initialValue: U_2): U_2;
+        find<S_2 extends string>(predicate: (value: string, index: number, obj: string[]) => value is S_2, thisArg?: any): S_2;
+        find(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): string;
+        findIndex(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): number;
+        fill(value: string, start?: number, end?: number): string[];
+        copyWithin(target: number, start: number, end?: number): string[];
+        entries(): IterableIterator<[number, string]>;
+        keys(): IterableIterator<number>;
+        values(): IterableIterator<string>;
+        includes(searchElement: string, fromIndex?: number): boolean;
+        flatMap<U_3, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_3 | readonly U_3[], thisArg?: This): U_3[];
+        flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
+        at(index: number): string;
+        [Symbol.iterator](): IterableIterator<string>;
+        [Symbol.unscopables]: {
+            [x: number]: boolean;
+            length?: boolean;
+            toString?: boolean;
+            toLocaleString?: boolean;
+            pop?: boolean;
+            push?: boolean;
+            concat?: boolean;
+            join?: boolean;
+            reverse?: boolean;
+            shift?: boolean;
+            slice?: boolean;
+            sort?: boolean;
+            splice?: boolean;
+            unshift?: boolean;
+            indexOf?: boolean;
+            lastIndexOf?: boolean;
+            every?: boolean;
+            some?: boolean;
+            forEach?: boolean;
+            map?: boolean;
+            filter?: boolean;
+            reduce?: boolean;
+            reduceRight?: boolean;
+            find?: boolean;
+            findIndex?: boolean;
+            fill?: boolean;
+            copyWithin?: boolean;
+            entries?: boolean;
+            keys?: boolean;
+            values?: boolean;
+            includes?: boolean;
+            flatMap?: boolean;
+            flat?: boolean;
+            at?: boolean;
+            [Symbol.iterator]?: boolean;
+            readonly [Symbol.unscopables]?: boolean;
+        };
+    };
+    get votingDisabled(): boolean;
+    /**
+     *
+     */
+    get state(): {};
+    get inProgress(): VoteView[];
+    /**
+     * 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[]): void;
+    canVote(address: address): boolean;
+    vote(voteId: string, vote: VoteResult): void;
+    disableVoting(): void;
+    grantVotingPower(address: address, voteId: string): void;
+    revokeVotingPower(address: address, voteId: string): void;
+    sync(): void;
+}

package/exports/voting.js

@@ -0,0 +1,133 @@
+class Voting {
+    #voters;
+    #votes;
+    #votingDisabled;
+    constructor(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 { voters: this.#voters, votes: this.#votes, votingDisabled: this.#votingDisabled };
+    }
+    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, description, endTime, method, args = []) {
+        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) {
+        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, 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(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, voteId) {
+        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, voteId) {
+        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);
+        }
+    }
+}
+
+export { Voting as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/standards",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Contract standards",
   "type": "module",
   "exports": {
@@ -16,8 +16,18 @@
       "import": "./exports/roles.js",
       "types": "./exports/roles.d.ts"
     },
+    "./voting": {
+      "import": "./exports/voting.js",
+      "types": "./exports/voting.d.ts"
+    },
+    "./helpers": {
+      "import": "./exports/helpers.js",
+      "types": "./exports/helpers.d.ts"
+    },
     "./token.js": "./exports/token.js",
-    "./roles.js": "./exports/roles.js"
+    "./roles.js": "./exports/roles.js",
+    "./voting.js": "./exports/voting.js",
+    "./helpers.js": "./exports/helpers.js"
   },
   "scripts": {
     "build": "rollup -c",

package/rollup.config.js

@@ -1,23 +1,20 @@
 import typescript from '@rollup/plugin-typescript'
-import tsConfig from './tsconfig.json' assert { type: 'json'}
+import tsConfig from './tsconfig.json' assert { type: 'json' }
 import { execSync } from 'child_process'
 
-
-
-
 // const templates = (await readdir('./src/templates')).map(path => join('./src/templates', path))
 const clean = () => {
   execSync('rm -rf www/*.js')
   return
 }
 
-export default [{
-  input: ['src/index.ts', 'src/token.ts', 'src/roles.ts'],
-  output: {
-    dir: './exports',
-    format: 'es'
-  },
-  plugins: [
-    typescript(tsConfig)
-  ]
-}]
+export default [
+  {
+    input: ['src/index.ts', 'src/token.ts', 'src/roles.ts', 'src/voting.ts', 'src/helpers.ts'],
+    output: {
+      dir: './exports',
+      format: 'es'
+    },
+    plugins: [typescript(tsConfig)]
+  }
+]

package/src/helpers.ts

@@ -0,0 +1,19 @@
+// when state is stored it get encoded as a string to  so we need to reformat balances back to BigNumbers
+export const restoreBalances = (balances) => {
+  const _balances = {}
+  for (const address in balances) {
+    _balances[address] = BigNumber['from'](balances[address])
+  }
+  return _balances
+}
+
+export const restoreApprovals = (approvals) => {
+  const _approvals = {}
+  for (const owner in approvals) {
+    _approvals[owner] = {}
+    for (const operator in approvals[owner]) {
+      _approvals[owner][operator] = BigNumber['from'](approvals[owner][operator])
+    }
+  }
+  return _approvals
+}

package/src/index.ts

@@ -1,2 +1,4 @@
 export { default as Token } from './token.js'
 export { default as Roles } from './roles.js'
+export { default as Voting } from './voting.js'
+export * from './helpers.js'

package/src/token.ts

@@ -1,10 +1,11 @@
+import { restoreApprovals, restoreBalances } from './helpers.js'
 import Roles from './roles.js'
 
 export declare type TokenState = {
   roles: { [index: string]: address[] }
-  holders: number
-  balances: { [index: string]: BigNumberish }
-  approvals: {}
+  holders: BigNumberish
+  balances: { [address: address]: BigNumberish }
+  approvals: { [owner: address]: { [operator: address]: BigNumberish } }
   totalSupply: BigNumberish
 }
 
@@ -28,11 +29,11 @@ export default class Token extends Roles {
   /**
    * Object => Object => uint
    */
-  #approvals = {}
+  #approvals: { [owner: string]: { [operator: string]: typeof BigNumber } } = {}
 
   #decimals = 18
 
-  #totalSupply = BigNumber['from'](0)
+  #totalSupply: typeof BigNumber = BigNumber['from'](0)
 
   // this.#privateField2 = 1
   constructor(name: string, symbol: string, decimals: number = 18, state?: TokenState) {
@@ -42,9 +43,9 @@ export default class Token extends Roles {
     super(state?.roles)
 
     if (state) {
+      this.#balances = restoreBalances(state.balances)
+      this.#approvals = restoreApprovals(state.approvals)
       this.#holders = BigNumber['from'](state.holders)
-      this.#balances = BigNumber['from'](state.balances)
-      this.#approvals = BigNumber['from'](state.approvals)
       this.#totalSupply = BigNumber['from'](state.totalSupply)
     } else {
       this.#name = name
@@ -138,7 +139,7 @@ export default class Token extends Roles {
   setApproval(operator: address, amount: BigNumberish) {
     const owner = msg.sender
     if (!this.#approvals[owner]) this.#approvals[owner] = {}
-    this.#approvals[owner][operator] = amount
+    this.#approvals[owner][operator] = BigNumber['from'](amount)
   }
 
   approved(owner: address, operator: address, amount: BigNumberish): boolean {

package/src/voting.ts

@@ -0,0 +1,178 @@
+export type VoteResult = 0 | 0.5 | 1
+
+export type Vote = {
+  title: string
+  method: string
+  args: any[]
+  description: string
+  endTime: EpochTimeStamp
+  results?: { [address: address]: VoteResult }
+  finished?: boolean
+  enoughVotes?: boolean
+}
+
+export type VotingState = {
+  voters: address[]
+  votes: {
+    [id: string]: Vote
+  }
+  votingDisabled: boolean
+}
+export interface VoteView extends Vote {
+  id: string
+}
+
+export default class Voting {
+  #voters: VotingState['voters']
+  #votes: VotingState['votes']
+  #votingDisabled: boolean
+
+  constructor(state: VotingState) {
+    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 { 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)
+    }
+  }
+}