@leofcoin/standards 0.1.6 → 0.1.8

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,6 @@
 export { default as Token } from './token.js';
 export { default as Roles } from './roles.js';
+export { default as TokenReceiver } from './token-receiver.js';
+export { default as PublicVoting } from './voting/public-voting.js';
+export { default as PrivateVoting } from './voting/private-voting.js';
+export * from './helpers.js';

package/exports/index.js

@@ -1,2 +1,6 @@
 export { default as Token } from './token.js';
 export { default as Roles } from './roles.js';
+export { default as TokenReceiver } from './token-receiver.js';
+export { default as PublicVoting } from './public-voting.js';
+export { default as PrivateVoting } from './private-voting.js';
+export { restoreApprovals, restoreBalances } from './helpers.js';

package/exports/private-voting.js

@@ -0,0 +1,133 @@
+class PrivateVoting {
+    #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 { PrivateVoting as default };

package/exports/public-voting.js

@@ -0,0 +1,98 @@
+import TokenReceiver from './token-receiver.js';
+
+/**
+ * allows everybody that has a balance greater or equeal then/to tokenAmountToReceive to vote
+ */
+class PublicVoting extends TokenReceiver {
+    #votes;
+    #votingDisabled;
+    constructor(tokenToReceive, tokenAmountToReceive, state) {
+        super(tokenToReceive, tokenAmountToReceive, state);
+        if (state) {
+            this.#votes = state.votes;
+            this.#votingDisabled = state.votingDisabled;
+        }
+    }
+    get votes() {
+        return { ...this.#votes };
+    }
+    get votingDisabled() {
+        return this.#votingDisabled;
+    }
+    /**
+     *
+     */
+    get state() {
+        return { ...super.state, 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.canPay();
+    }
+    #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, 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`);
+        await msg.staticCall(this.tokenToReceive, 'burn', [this.tokenAmountToReceive]);
+        this.#votes[voteId][msg.sender] = vote;
+    }
+    #disableVoting() {
+        this.#votingDisabled = true;
+    }
+    disableVoting() {
+        if (!this.canVote(msg.sender))
+            throw new Error('not a allowed');
+        else {
+            this.createVote(`disable voting`, `Warning this disables all voting features forever`, new Date().getTime() + 172800000, '#disableVoting', []);
+        }
+    }
+    sync() {
+        for (const vote of this.inProgress) {
+            if (vote.endTime < new Date().getTime())
+                this.#endVoting(vote.id);
+        }
+    }
+}
+
+export { PublicVoting as default };

package/exports/token-receiver.d.ts

@@ -0,0 +1,19 @@
+export interface TokenReceiverState {
+    tokenToReceive: address;
+    tokenAmountToReceive: typeof BigNumber;
+}
+export default class TokenReceiver {
+    #private;
+    constructor(tokenToReceive: address, tokenAmountToReceive: typeof BigNumber, state: TokenReceiverState);
+    get tokenToReceive(): string;
+    get tokenAmountToReceive(): import("@ethersproject/bignumber").BigNumber;
+    get state(): {
+        tokenToReceive: string;
+        tokenAmountToReceive: import("@ethersproject/bignumber").BigNumber;
+    };
+    /**
+     * check if sender can pay
+     * @returns {boolean} promise
+     */
+    canPay(): Promise<boolean>;
+}

package/exports/token-receiver.js

@@ -0,0 +1,36 @@
+class TokenReceiver {
+    #tokenToReceive;
+    #tokenAmountToReceive;
+    constructor(tokenToReceive, tokenAmountToReceive, state) {
+        if (state) {
+            this.#tokenToReceive = state.tokenToReceive;
+            this.#tokenAmountToReceive = BigNumber['from'](state.tokenAmountToReceive);
+        }
+        else {
+            this.#tokenToReceive = tokenToReceive;
+            this.#tokenAmountToReceive = BigNumber['from'](tokenAmountToReceive);
+        }
+    }
+    get tokenToReceive() {
+        return this.#tokenToReceive;
+    }
+    get tokenAmountToReceive() {
+        return this.#tokenAmountToReceive;
+    }
+    get state() {
+        return {
+            tokenToReceive: this.#tokenToReceive,
+            tokenAmountToReceive: this.#tokenAmountToReceive
+        };
+    }
+    /**
+     * check if sender can pay
+     * @returns {boolean} promise
+     */
+    async canPay() {
+        const amount = (await msg.staticCall(this.#tokenToReceive, 'balanceOf', [msg.sender]));
+        return amount.gte(this.#tokenAmountToReceive);
+    }
+}
+
+export { TokenReceiver as default };

package/exports/token.js

@@ -1,24 +1,6 @@
+import { restoreBalances, restoreApprovals } from './helpers.js';
 import Roles from './roles.js';
 
-// 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;
-};
-
 class Token extends Roles {
     /**
      * string

package/exports/voting/private-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 PrivateVotingState = {
+    voters: address[];
+    votes: {
+        [id: string]: Vote;
+    };
+    votingDisabled: boolean;
+};
+export interface VoteView extends Vote {
+    id: string;
+}
+export default class PrivateVoting {
+    #private;
+    constructor(state: PrivateVotingState);
+    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/public-voting.d.ts

@@ -0,0 +1,51 @@
+import TokenReceiver, { TokenReceiverState } from '../token-receiver.js';
+export type VoteResult = 0 | 0.5 | 1;
+export type PublicVote = {
+    title: string;
+    method: string;
+    args: any[];
+    description: string;
+    endTime: EpochTimeStamp;
+    results?: {
+        [address: address]: VoteResult;
+    };
+    finished?: boolean;
+    enoughVotes?: boolean;
+};
+export interface PublicVotingState extends TokenReceiverState {
+    votes: {
+        [id: string]: PublicVote;
+    };
+    votingDisabled: boolean;
+}
+export interface VoteView extends PublicVote {
+    id: string;
+}
+/**
+ * allows everybody that has a balance greater or equeal then/to tokenAmountToReceive to vote
+ */
+export default class PublicVoting extends TokenReceiver {
+    #private;
+    constructor(tokenToReceive: address, tokenAmountToReceive: typeof BigNumber, state: PublicVotingState);
+    get votes(): {
+        [x: string]: PublicVote;
+    };
+    get votingDisabled(): boolean;
+    /**
+     *
+     */
+    get state(): PublicVotingState;
+    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): Promise<boolean>;
+    vote(voteId: string, vote: VoteResult): Promise<void>;
+    disableVoting(): void;
+    sync(): void;
+}

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.6",
+  "version": "0.1.8",
   "description": "Contract standards",
   "type": "module",
   "exports": {
@@ -16,8 +16,27 @@
       "import": "./exports/roles.js",
       "types": "./exports/roles.d.ts"
     },
+    "./public-voting": {
+      "import": "./exports/public-voting.js",
+      "types": "./exports/public-voting.d.ts"
+    },
+    "./private-voting": {
+      "import": "./exports/private-voting.js",
+      "types": "./exports/private-voting.d.ts"
+    },
+    "./token-receiver": {
+      "import": "./exports/token-receiver.js",
+      "types": "./exports/token-receiver.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",
+    "./public-voting.js": "./exports/public-voting.js",
+    "./private-voting.js": "./exports/private-voting.js",
+    "./helpers.js": "./exports/helpers.js"
   },
   "scripts": {
     "build": "rollup -c",

package/rollup.config.js

@@ -1,23 +1,28 @@
 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/public-voting.ts',
+      'src/voting/private-voting.ts',
+      'src/helpers.ts',
+      'src/token-receiver.ts'
+    ],
+    output: {
+      dir: './exports',
+      format: 'es'
+    },
+    plugins: [typescript(tsConfig)]
+  }
+]

package/src/index.ts

@@ -1,2 +1,7 @@
 export { default as Token } from './token.js'
 export { default as Roles } from './roles.js'
+export { default as TokenReceiver } from './token-receiver.js'
+export { default as PublicVoting } from './voting/public-voting.js'
+export { default as PrivateVoting } from './voting/private-voting.js'
+
+export * from './helpers.js'

package/src/token-receiver.ts

@@ -0,0 +1,41 @@
+export interface TokenReceiverState {
+  tokenToReceive: address
+  tokenAmountToReceive: typeof BigNumber
+}
+export default class TokenReceiver {
+  #tokenToReceive: address
+  #tokenAmountToReceive: typeof BigNumber
+  constructor(tokenToReceive: address, tokenAmountToReceive: typeof BigNumber, state: TokenReceiverState) {
+    if (state) {
+      this.#tokenToReceive = state.tokenToReceive
+      this.#tokenAmountToReceive = BigNumber['from'](state.tokenAmountToReceive)
+    } else {
+      this.#tokenToReceive = tokenToReceive
+      this.#tokenAmountToReceive = BigNumber['from'](tokenAmountToReceive)
+    }
+  }
+
+  get tokenToReceive() {
+    return this.#tokenToReceive
+  }
+
+  get tokenAmountToReceive() {
+    return this.#tokenAmountToReceive
+  }
+
+  get state() {
+    return {
+      tokenToReceive: this.#tokenToReceive,
+      tokenAmountToReceive: this.#tokenAmountToReceive
+    }
+  }
+
+  /**
+   * check if sender can pay
+   * @returns {boolean} promise
+   */
+  async canPay(): Promise<boolean> {
+    const amount = (await msg.staticCall(this.#tokenToReceive, 'balanceOf', [msg.sender])) as typeof BigNumber
+    return amount.gte(this.#tokenAmountToReceive)
+  }
+}

package/src/voting/private-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 PrivateVotingState = {
+  voters: address[]
+  votes: {
+    [id: string]: Vote
+  }
+  votingDisabled: boolean
+}
+export interface VoteView extends Vote {
+  id: string
+}
+
+export default class PrivateVoting {
+  #voters: PrivateVotingState['voters']
+  #votes: PrivateVotingState['votes']
+  #votingDisabled: boolean
+
+  constructor(state: PrivateVotingState) {
+    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)
+    }
+  }
+}

package/src/voting/public-voting.ts

@@ -0,0 +1,130 @@
+import TokenReceiver, { TokenReceiverState } from '../token-receiver.js'
+import PrivateVoting from './private-voting.js'
+
+export type VoteResult = 0 | 0.5 | 1
+
+export type PublicVote = {
+  title: string
+  method: string
+  args: any[]
+  description: string
+  endTime: EpochTimeStamp
+  results?: { [address: address]: VoteResult }
+  finished?: boolean
+  enoughVotes?: boolean
+}
+
+export interface PublicVotingState extends TokenReceiverState {
+  votes: {
+    [id: string]: PublicVote
+  }
+  votingDisabled: boolean
+}
+export interface VoteView extends PublicVote {
+  id: string
+}
+
+/**
+ * allows everybody that has a balance greater or equeal then/to tokenAmountToReceive to vote
+ */
+export default class PublicVoting extends TokenReceiver {
+  #votes: PublicVotingState['votes']
+  #votingDisabled: boolean
+
+  constructor(tokenToReceive: address, tokenAmountToReceive: typeof BigNumber, state: PublicVotingState) {
+    super(tokenToReceive, tokenAmountToReceive, state)
+    if (state) {
+      this.#votes = state.votes
+      this.#votingDisabled = state.votingDisabled
+    }
+  }
+
+  get votes() {
+    return { ...this.#votes }
+  }
+
+  get votingDisabled() {
+    return this.#votingDisabled
+  }
+
+  /**
+   *
+   */
+  get state(): PublicVotingState {
+    return { ...super.state, 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.canPay()
+  }
+
+  #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(msg.sender)) throw new Error(`Not allowed to vote`)
+    await msg.staticCall(this.tokenToReceive, 'burn', [this.tokenAmountToReceive])
+    this.#votes[voteId][msg.sender] = vote
+  }
+
+  #disableVoting() {
+    this.#votingDisabled = true
+  }
+
+  disableVoting() {
+    if (!this.canVote(msg.sender)) throw new Error('not a allowed')
+    else {
+      this.createVote(
+        `disable voting`,
+        `Warning this disables all voting features forever`,
+        new Date().getTime() + 172800000,
+        '#disableVoting',
+        []
+      )
+    }
+  }
+
+  sync() {
+    for (const vote of this.inProgress) {
+      if (vote.endTime < new Date().getTime()) this.#endVoting(vote.id)
+    }
+  }
+}

package/tsconfig.json

@@ -3,12 +3,14 @@
     "module": "NodeNext",
     "target": "es2022",
     "outDir": "./exports",
-    "moduleResolution":"NodeNext",
+    "moduleResolution": "NodeNext",
     "declaration": true,
     "declarationDir": "./exports"
   },
   "include": [
     "./src/*",
-    "./node_modules/@leofcoin/global-types/*"
+    "./node_modules/@leofcoin/global-types/*",
+    "src/voting/private-voting.ts",
+    "src/voting/public-voting.ts"
   ]
-}
+}