@leofcoin/standards 0.1.7 → 0.2.0

package/.changeset/README.md

@@ -0,0 +1,8 @@
+# Changesets
+
+Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
+with multi-package repos, or single-package repos to help you version and publish your code. You can
+find the full documentation for it [in our repository](https://github.com/changesets/changesets)
+
+We have a quick list of common questions to get you started engaging with this project in
+[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

package/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.0.0/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "public",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @leofcoin/standards
+
+## 0.2.0
+
+### Minor Changes
+
+- Add voting & tokenReceiver

package/README.md

@@ -1,21 +1,23 @@
 # standards
+
 > Contract standards
 
 standards used in leofcoin chain kinda like erc20's but the native coin included
 
 ## install
+
 ```sh
 npm i @leofcoin/standards
 ```
 
 ## usage
+
 ```js
-import {Token} from '@leofcoin/standards'
+import { Token } from '@leofcoin/standards'
 
 class myCoolToken extends Token {
-  constructor() {
-    super('myCoolToken', 'MCT', 18, state?)
+  constructor(state) {
+    super('myCoolToken', 'MCT', 18, state)
   }
 }
 ```
-

package/exports/index.d.ts

@@ -1,4 +1,6 @@
 export { default as Token } from './token.js';
 export { default as Roles } from './roles.js';
-export { default as Voting } from './voting.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,4 +1,6 @@
 export { default as Token } from './token.js';
 export { default as Roles } from './roles.js';
-export { default as Voting } from './voting.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,104 @@
+/**
+ * allows everybody that has a balance greater or equeal then/to tokenAmountToReceive to vote
+ */
+class PublicVoting {
+    #votes;
+    #votingDisabled;
+    #votingDuration = 172800000;
+    constructor(state) {
+        if (state) {
+            this.#votes = state.votes;
+            this.#votingDisabled = state.votingDisabled;
+        }
+    }
+    get votes() {
+        return { ...this.#votes };
+    }
+    get votingDuration() {
+        return this.#votingDuration;
+    }
+    get votingDisabled() {
+        return this.#votingDisabled;
+    }
+    /**
+     *
+     */
+    get state() {
+        return { votes: this.#votes, votingDisabled: this.#votingDisabled, votingDuration: this.#votingDuration };
+    }
+    get inProgress() {
+        return Object.entries(this.#votes)
+            .filter(([id, vote]) => !vote.finished)
+            .map(([id, vote]) => {
+            return { ...vote, id };
+        });
+    }
+    /**
+     * create vote
+     * @param {string} vote
+     * @param {string} description
+     * @param {number} endTime
+     * @param {string} method function to run when agree amount is bigger
+     */
+    createVote(title, 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
+        };
+    }
+    #canVote() {
+        // @ts-expect-error
+        return this._canVote?.();
+    }
+    #beforeVote() {
+        // @ts-expect-error
+        return this._beforeVote?.();
+    }
+    #endVoting(voteId) {
+        let agree = Object.values(this.#votes[voteId].results).filter((result) => result === 1);
+        let disagree = Object.values(this.#votes[voteId].results).filter((result) => result === 0);
+        if (agree.length > disagree.length && this.#votes[voteId].enoughVotes)
+            this[this.#votes[voteId].method](...this.#votes[voteId].args);
+        this.#votes[voteId].finished = true;
+    }
+    async vote(voteId, 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;
+    }
+    #disableVoting() {
+        this.#votingDisabled = true;
+    }
+    disableVoting() {
+        if (!this.#canVote())
+            throw new Error('not a allowed');
+        else {
+            this.createVote(`disable voting`, `Warning this disables all voting features forever`, new Date().getTime() + this.#votingDuration, '#disableVoting', []);
+        }
+    }
+    _sync() {
+        for (const vote of this.inProgress) {
+            if (vote.endTime < new Date().getTime())
+                this.#endVoting(vote.id);
+        }
+    }
+}
+
+export { PublicVoting as default };

package/exports/token-receiver.d.ts

@@ -0,0 +1,47 @@
+import { IPublicVoting } from './voting/interfaces/public-voting.js';
+import PublicVoting from './voting/public-voting.js';
+import { VotingState } from './voting/types.js';
+export interface TokenReceiverState extends VotingState {
+    tokenToReceive: address;
+    tokenReceiver: address;
+    tokenAmountToReceive: typeof BigNumber;
+    voteType: 'burn' | 'transfer';
+}
+export default class TokenReceiver extends PublicVoting implements IPublicVoting {
+    #private;
+    constructor(tokenToReceive: address, tokenAmountToReceive: typeof BigNumber, burns: boolean, state?: TokenReceiverState);
+    get tokenToReceive(): string;
+    get tokenAmountToReceive(): import("@ethersproject/bignumber").BigNumber;
+    get tokenReceiver(): string;
+    get state(): {
+        tokenReceiver: string;
+        tokenToReceive: string;
+        tokenAmountToReceive: import("@ethersproject/bignumber").BigNumber;
+        voteType: "burn" | "transfer";
+        votes: {
+            [id: string]: import("./voting/types.js").Vote;
+        };
+        votingDisabled: boolean;
+        votingDuration: number;
+    };
+    /**
+     * check if sender can pay
+     * @returns {boolean} promise
+     */
+    _canVote(): Promise<boolean>;
+    _beforeVote(): Promise<any>;
+    /**
+     * check if sender can pay
+     * @returns {boolean} promise
+     */
+    _payTokenToReceive(): Promise<boolean>;
+    /**
+     * check if sender can pay
+     * @returns {boolean} promise
+     */
+    _burnTokenToReceive(): Promise<boolean>;
+    changeVoteType(type: TokenReceiverState['voteType']): Promise<void>;
+    getTokensOut(amount: typeof BigNumber, receiver: address): void;
+    changeTokenAmountToReceive(): void;
+    changeTokenToReceive(): Promise<void>;
+}

package/exports/token-receiver.js

@@ -0,0 +1,128 @@
+import PublicVoting from './public-voting.js';
+
+class TokenReceiver extends PublicVoting {
+    #tokenToReceive;
+    #tokenAmountToReceive;
+    #tokenReceiver;
+    #voteType = 'transfer';
+    constructor(tokenToReceive, tokenAmountToReceive, burns, state) {
+        super(state);
+        if (state) {
+            this.#tokenReceiver = state.tokenReceiver;
+            this.#tokenToReceive = state.tokenToReceive;
+            this.#tokenAmountToReceive = BigNumber['from'](state.tokenAmountToReceive);
+            this.#voteType = state.voteType;
+        }
+        else {
+            this.#tokenReceiver = msg.contract;
+            this.#tokenToReceive = tokenToReceive;
+            this.#tokenAmountToReceive = BigNumber['from'](tokenAmountToReceive);
+            if (burns)
+                this.#voteType = 'burn';
+        }
+    }
+    get tokenToReceive() {
+        return this.#tokenToReceive;
+    }
+    get tokenAmountToReceive() {
+        return this.#tokenAmountToReceive;
+    }
+    get tokenReceiver() {
+        return this.#tokenReceiver;
+    }
+    get state() {
+        return {
+            ...super.state,
+            tokenReceiver: this.#tokenReceiver,
+            tokenToReceive: this.#tokenToReceive,
+            tokenAmountToReceive: this.#tokenAmountToReceive,
+            voteType: this.#voteType
+        };
+    }
+    async #canVote() {
+        const amount = (await msg.staticCall(this.#tokenToReceive, 'balanceOf', [msg.sender]));
+        return amount.gte(this.#tokenAmountToReceive);
+    }
+    /**
+     * check if sender can pay
+     * @returns {boolean} promise
+     */
+    async _canVote() {
+        return this.#canVote();
+    }
+    async #beforeVote() {
+        if (this.#voteType === 'burn')
+            return msg.staticCall(this.tokenToReceive, 'burn', [this.tokenAmountToReceive]);
+        return msg.staticCall(this.tokenToReceive, 'transfer', [msg.sender, this.tokenReceiver, this.tokenAmountToReceive]);
+    }
+    async _beforeVote() {
+        await this.#beforeVote();
+    }
+    /**
+     * check if sender can pay
+     * @returns {boolean} promise
+     */
+    async _payTokenToReceive() {
+        return msg.staticCall(this.#tokenToReceive, 'transfer', [
+            msg.sender,
+            this.#tokenReceiver,
+            this.#tokenAmountToReceive
+        ]);
+    }
+    /**
+     * check if sender can pay
+     * @returns {boolean} promise
+     */
+    async _burnTokenToReceive() {
+        return msg.staticCall(this.#tokenToReceive, 'burn', [this.#tokenAmountToReceive]);
+    }
+    #changeTokenToReceive(address) {
+        this.#tokenToReceive = address;
+    }
+    #changeTokenAmountToReceive(amount) {
+        this.#tokenAmountToReceive = amount;
+    }
+    #changeVoteType(type) {
+        this.#voteType = type;
+    }
+    #getTokensOut(amount, receiver) {
+        return msg.call(this.#tokenReceiver, 'transfer', [this.#tokenReceiver, receiver, amount]);
+    }
+    async changeVoteType(type) {
+        if (!this.#canVote())
+            throw new Error('not a allowed');
+        if (this.#voteType === 'transfer' && (await this.#balance()).gt(0))
+            throw new Error('get tokens out first or they be lost forever');
+        else {
+            this.createVote(`change the token amount to receive`, `set tokenAmountToReceive`, new Date().getTime() + this.votingDuration, '#changeVoteType', [type]);
+        }
+    }
+    getTokensOut(amount, receiver) {
+        if (!this.#canVote())
+            throw new Error('not a allowed');
+        else {
+            this.createVote(`withdraw all tokens`, `withdraw all tokens to ${receiver}`, new Date().getTime() + this.votingDuration, '#getTokensOut', [amount, receiver]);
+        }
+    }
+    changeTokenAmountToReceive() {
+        if (!this.#canVote())
+            throw new Error('not a allowed');
+        else {
+            this.createVote(`change the token amount to receive`, `set tokenAmountToReceive`, new Date().getTime() + this.votingDuration, '#changeTokenAmountToReceive', []);
+        }
+    }
+    #balance() {
+        return msg.staticCall(this.#tokenToReceive, 'balanceOf', [this.#tokenReceiver]);
+    }
+    async changeTokenToReceive() {
+        if (!this.#canVote())
+            throw new Error('not a allowed');
+        if (!(await this.#balance()).eq(0) && this.#voteType === 'transfer')
+            throw new Error('get tokens out first or they be lost forever');
+        else {
+            this.createVote(`change the token to receive`, `set tokenToReceive to a new address`, new Date().getTime() + this.votingDuration, '#changeTokenToReceive', []);
+        }
+    }
+}
+
+export { TokenReceiver as default };

package/exports/token.d.ts

@@ -26,9 +26,15 @@ export default class Token extends Roles {
     get symbol(): string;
     get holders(): {};
     get balances(): {};
+    get approvals(): {
+        [owner: string]: {
+            [operator: string]: import("@ethersproject/bignumber").BigNumber;
+        };
+    };
     get decimals(): number;
     mint(to: address, amount: BigNumberish): void;
     burn(from: address, amount: BigNumberish): void;
+    balance(): any;
     balanceOf(address: address): BigNumberish;
     setApproval(operator: address, amount: BigNumberish): void;
     approved(owner: address, operator: address, amount: BigNumberish): boolean;

package/exports/token.js

@@ -73,6 +73,9 @@ class Token extends Roles {
     get balances() {
         return { ...this.#balances };
     }
+    get approvals() {
+        return this.#approvals;
+    }
     get decimals() {
         return this.#decimals;
     }
@@ -110,6 +113,9 @@ class Token extends Roles {
         this.#balances[address] = this.#balances[address].sub(amount);
         this.#updateHolders(address, previousBalance);
     }
+    balance() {
+        return this.#balances[msg.sender];
+    }
     balanceOf(address) {
         return this.#balances[address];
     }

package/exports/voting/interfaces/public-voting.d.ts

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

package/exports/voting/private-voting.d.ts

@@ -0,0 +1,32 @@
+import { VoteResult, VoteView, VotingState } from './types.js';
+export interface PrivateVotingState extends VotingState {
+    voters: any;
+}
+export default class PrivateVoting {
+    #private;
+    constructor(state: PrivateVotingState);
+    get votes(): {
+        [x: string]: import("./types.js").Vote;
+    };
+    get voters(): any;
+    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): any;
+    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,47 @@
+import { VotingState, VoteResult } from './types.js';
+/**
+ * allows everybody that has a balance greater or equeal then/to tokenAmountToReceive to vote
+ */
+export default class PublicVoting {
+    #private;
+    constructor(state: VotingState);
+    get votes(): {
+        [x: string]: import("./types.js").Vote;
+    };
+    get votingDuration(): number;
+    get votingDisabled(): boolean;
+    /**
+     *
+     */
+    get state(): {
+        votes: {
+            [id: string]: import("./types.js").Vote;
+        };
+        votingDisabled: boolean;
+        votingDuration: number;
+    };
+    get inProgress(): {
+        id: string;
+        title: string;
+        method: string;
+        args: any[];
+        description: string;
+        endTime: number;
+        results?: {
+            [address: string]: VoteResult;
+        };
+        finished?: boolean;
+        enoughVotes?: boolean;
+    }[];
+    /**
+     * 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;
+    vote(voteId: string, vote: VoteResult): Promise<void>;
+    disableVoting(): void;
+    _sync(): void;
+}

package/exports/voting/types.d.ts

@@ -0,0 +1,23 @@
+export type VoteResult = 0 | 0.5 | 1;
+export type Vote = {
+    title: string;
+    method: string;
+    args: any[];
+    description: string;
+    endTime: EpochTimeStamp;
+    results?: {
+        [address: string]: VoteResult;
+    };
+    finished?: boolean;
+    enoughVotes?: boolean;
+};
+export interface VotingState {
+    votes: {
+        [id: string]: Vote;
+    };
+    votingDisabled: boolean;
+    votingDuration: number;
+}
+export interface VoteView extends Vote {
+    id: string;
+}

package/package.json

@@ -1,56 +1,66 @@
-{
-  "name": "@leofcoin/standards",
-  "version": "0.1.7",
-  "description": "Contract standards",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./exports/index.js",
-      "types": "./exports/index.d.ts"
-    },
-    "./token": {
-      "import": "./exports/token.js",
-      "types": "./exports/token.d.ts"
-    },
-    "./roles": {
-      "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",
-    "./voting.js": "./exports/voting.js",
-    "./helpers.js": "./exports/helpers.js"
-  },
-  "scripts": {
-    "build": "rollup -c",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ArteonToken/standards.git"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/ArteonToken/standards/issues"
-  },
-  "homepage": "https://github.com/ArteonToken/standards#readme",
-  "devDependencies": {
-    "@leofcoin/global-types": "^1.0.0",
-    "@rollup/plugin-typescript": "^11.0.0",
-    "rollup": "^3.17.1",
-    "tslib": "^2.5.0"
-  },
-  "dependencies": {
-    "@ethersproject/bignumber": "^5.7.0"
-  }
-}
+{
+  "name": "@leofcoin/standards",
+  "version": "0.2.0",
+  "description": "Contract standards",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./exports/index.js",
+      "types": "./exports/index.d.ts"
+    },
+    "./token": {
+      "import": "./exports/token.js",
+      "types": "./exports/token.d.ts"
+    },
+    "./roles": {
+      "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",
+    "./public-voting.js": "./exports/public-voting.js",
+    "./private-voting.js": "./exports/private-voting.js",
+    "./helpers.js": "./exports/helpers.js"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ArteonToken/standards.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ArteonToken/standards/issues"
+  },
+  "homepage": "https://github.com/ArteonToken/standards#readme",
+  "devDependencies": {
+    "@leofcoin/global-types": "^1.0.0",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "rollup": "^4.12.0",
+    "tslib": "^2.5.0"
+  },
+  "dependencies": {
+    "@changesets/cli": "^2.27.1",
+    "@ethersproject/bignumber": "^5.7.0"
+  }
+}

package/rollup.config.js

@@ -1,5 +1,4 @@
 import typescript from '@rollup/plugin-typescript'
-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))
@@ -10,11 +9,19 @@ const clean = () => {
 
 export default [
   {
-    input: ['src/index.ts', 'src/token.ts', 'src/roles.ts', 'src/voting.ts', 'src/helpers.ts'],
+    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)]
+    plugins: [typescript()]
   }
 ]

package/src/index.ts

@@ -1,4 +1,7 @@
 export { default as Token } from './token.js'
 export { default as Roles } from './roles.js'
-export { default as Voting } from './voting.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,176 @@
+import { IPublicVoting } from './voting/interfaces/public-voting.js'
+import PublicVoting from './voting/public-voting.js'
+import { VotingState } from './voting/types.js'
+
+export interface TokenReceiverState extends VotingState {
+  tokenToReceive: address
+  tokenReceiver: address
+  tokenAmountToReceive: typeof BigNumber
+  voteType: 'burn' | 'transfer'
+}
+export default class TokenReceiver extends PublicVoting implements IPublicVoting {
+  #tokenToReceive: address
+  #tokenAmountToReceive: typeof BigNumber
+  #tokenReceiver: address
+  #voteType: TokenReceiverState['voteType'] = 'transfer'
+
+  constructor(
+    tokenToReceive: address,
+    tokenAmountToReceive: typeof BigNumber,
+    burns: boolean,
+    state?: TokenReceiverState
+  ) {
+    super(state)
+    if (state) {
+      this.#tokenReceiver = state.tokenReceiver
+      this.#tokenToReceive = state.tokenToReceive
+      this.#tokenAmountToReceive = BigNumber['from'](state.tokenAmountToReceive)
+      this.#voteType = state.voteType
+    } else {
+      this.#tokenReceiver = msg.contract
+      this.#tokenToReceive = tokenToReceive
+      this.#tokenAmountToReceive = BigNumber['from'](tokenAmountToReceive)
+      if (burns) this.#voteType = 'burn'
+    }
+  }
+
+  get tokenToReceive() {
+    return this.#tokenToReceive
+  }
+
+  get tokenAmountToReceive() {
+    return this.#tokenAmountToReceive
+  }
+
+  get tokenReceiver() {
+    return this.#tokenReceiver
+  }
+
+  get state() {
+    return {
+      ...super.state,
+      tokenReceiver: this.#tokenReceiver,
+      tokenToReceive: this.#tokenToReceive,
+      tokenAmountToReceive: this.#tokenAmountToReceive,
+      voteType: this.#voteType
+    }
+  }
+
+  async #canVote() {
+    const amount = (await msg.staticCall(this.#tokenToReceive, 'balanceOf', [msg.sender])) as typeof BigNumber
+    return amount.gte(this.#tokenAmountToReceive)
+  }
+
+  /**
+   * check if sender can pay
+   * @returns {boolean} promise
+   */
+  async _canVote(): Promise<boolean> {
+    return this.#canVote()
+  }
+
+  async #beforeVote(): Promise<any> {
+    if (this.#voteType === 'burn') return msg.staticCall(this.tokenToReceive, 'burn', [this.tokenAmountToReceive])
+    return msg.staticCall(this.tokenToReceive, 'transfer', [msg.sender, this.tokenReceiver, this.tokenAmountToReceive])
+  }
+
+  async _beforeVote(): Promise<any> {
+    await this.#beforeVote()
+  }
+
+  /**
+   * check if sender can pay
+   * @returns {boolean} promise
+   */
+  async _payTokenToReceive(): Promise<boolean> {
+    return msg.staticCall(this.#tokenToReceive, 'transfer', [
+      msg.sender,
+      this.#tokenReceiver,
+      this.#tokenAmountToReceive
+    ])
+  }
+
+  /**
+   * check if sender can pay
+   * @returns {boolean} promise
+   */
+  async _burnTokenToReceive(): Promise<boolean> {
+    return msg.staticCall(this.#tokenToReceive, 'burn', [this.#tokenAmountToReceive])
+  }
+
+  #changeTokenToReceive(address: address) {
+    this.#tokenToReceive = address
+  }
+
+  #changeTokenAmountToReceive(amount: typeof BigNumber) {
+    this.#tokenAmountToReceive = amount
+  }
+
+  #changeVoteType(type: TokenReceiverState['voteType']) {
+    this.#voteType = type
+  }
+
+  #getTokensOut(amount: typeof BigNumber, receiver: address) {
+    return msg.call(this.#tokenReceiver, 'transfer', [this.#tokenReceiver, receiver, amount])
+  }
+
+  async changeVoteType(type: TokenReceiverState['voteType']) {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    if (this.#voteType === 'transfer' && (await this.#balance()).gt(0))
+      throw new Error('get tokens out first or they be lost forever')
+    else {
+      this.createVote(
+        `change the token amount to receive`,
+        `set tokenAmountToReceive`,
+        new Date().getTime() + this.votingDuration,
+        '#changeVoteType',
+        [type]
+      )
+    }
+  }
+
+  getTokensOut(amount: typeof BigNumber, receiver: address) {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    else {
+      this.createVote(
+        `withdraw all tokens`,
+        `withdraw all tokens to ${receiver}`,
+        new Date().getTime() + this.votingDuration,
+        '#getTokensOut',
+        [amount, receiver]
+      )
+    }
+  }
+
+  changeTokenAmountToReceive() {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    else {
+      this.createVote(
+        `change the token amount to receive`,
+        `set tokenAmountToReceive`,
+        new Date().getTime() + this.votingDuration,
+        '#changeTokenAmountToReceive',
+        []
+      )
+    }
+  }
+
+  #balance(): Promise<typeof BigNumber> {
+    return msg.staticCall(this.#tokenToReceive, 'balanceOf', [this.#tokenReceiver])
+  }
+
+  async changeTokenToReceive() {
+    if (!this.#canVote()) throw new Error('not a allowed')
+    if (!(await this.#balance()).eq(0) && this.#voteType === 'transfer')
+      throw new Error('get tokens out first or they be lost forever')
+    else {
+      this.createVote(
+        `change the token to receive`,
+        `set tokenToReceive to a new address`,
+        new Date().getTime() + this.votingDuration,
+        '#changeTokenToReceive',
+        []
+      )
+    }
+  }
+}

package/src/token.ts

@@ -90,6 +90,10 @@ export default class Token extends Roles {
     return { ...this.#balances }
   }
 
+  get approvals() {
+    return this.#approvals
+  }
+
   get decimals() {
     return this.#decimals
   }
@@ -132,6 +136,10 @@ export default class Token extends Roles {
     this.#updateHolders(address, previousBalance)
   }
 
+  balance() {
+    return this.#balances[msg.sender]
+  }
+
   balanceOf(address: address): BigNumberish {
     return this.#balances[address]
   }

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

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

package/src/{voting.ts → voting/private-voting.ts}

@@ -1,33 +1,15 @@
-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
-}
+import { VoteResult, VoteView, VotingState } from './types.js'
 
-export type VotingState = {
-  voters: address[]
-  votes: {
-    [id: string]: Vote
-  }
-  votingDisabled: boolean
-}
-export interface VoteView extends Vote {
-  id: string
+export interface PrivateVotingState extends VotingState {
+  voters
 }
 
-export default class Voting {
-  #voters: VotingState['voters']
-  #votes: VotingState['votes']
+export default class PrivateVoting {
+  #voters: PrivateVotingState['voters']
+  #votes: PrivateVotingState['votes']
   #votingDisabled: boolean
 
-  constructor(state: VotingState) {
+  constructor(state: PrivateVotingState) {
     if (state) {
       this.#voters = state.voters
       this.#votes = state.votes

package/src/voting/public-voting.ts

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

package/src/voting/types.ts

@@ -0,0 +1,24 @@
+export type VoteResult = 0 | 0.5 | 1
+
+export type Vote = {
+  title: string
+  method: string
+  args: any[]
+  description: string
+  endTime: EpochTimeStamp
+  results?: { [address: string]: VoteResult }
+  finished?: boolean
+  enoughVotes?: boolean
+}
+
+export interface VotingState {
+  votes: {
+    [id: string]: Vote
+  }
+  votingDisabled: boolean
+  votingDuration: number
+}
+
+export interface VoteView extends Vote {
+  id: string
+}

package/test/public-voting.js

@@ -0,0 +1,6 @@
+import Voting from './../exports/public-voting.js'
+
+const voting = new Voting('0x0', '1000')
+
+console.log(voting)
+console.log(voting.votingDuration)

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"
   ]
-}
+}