@leofcoin/standards 0.2.7 → 0.2.8

package/exports/index.js

@@ -5,3 +5,4 @@ export { default as PublicVoting } from './public-voting.js';
 export { default as PrivateVoting } from './private-voting.js';
 export { restoreApprovals, restoreBalances } from './helpers.js';
 import './contract-creator.js';
+import './voting-xYjJlN2h.js';

package/exports/private-voting.js

@@ -1,104 +1,25 @@
-import ContractCreator from './contract-creator.js';
+import { V as Voting } from './voting-xYjJlN2h.js';
+import './contract-creator.js';
 
-class PrivateVoting extends ContractCreator {
+class PrivateVoting extends Voting {
     #voters;
-    #votes;
-    #votingDisabled;
-    #votingDuration = 172800000;
     constructor(state) {
         super(state);
         if (state) {
             this.#voters = state.voters;
-            this.#votes = state.votes;
-            this.#votingDisabled = state.votingDisabled;
-            this.#votingDuration = state.votingDuration;
         }
         else {
             this.#voters = [msg.sender];
         }
     }
-    get votes() {
-        return { ...this.#votes };
-    }
-    get voters() {
-        return { ...this.#voters };
-    }
-    get votingDisabled() {
-        return this.#votingDisabled;
-    }
-    /**
-     *
-     */
     get state() {
         return {
             ...super.state,
-            voters: this.#voters,
-            votes: this.#votes,
-            votingDisabled: this.#votingDisabled,
-            votingDuration: this.#votingDuration
+            voters: this.#voters
         };
     }
-    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 = [];
+    _canVote() {
+        return this.#voters.includes(msg.sender);
     }
     #grantVotingPower(address) {
         this.#voters.push(address);
@@ -106,37 +27,22 @@ class PrivateVoting extends ContractCreator {
     #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() + this.#votingDuration, '#disableVoting', []);
-        }
-    }
     grantVotingPower(address, voteId) {
-        if (this.#voters.length === 1 && this.canVote(msg.sender))
+        if (this.#voters.length === 1 && this._canVote())
             this.#grantVotingPower(address);
         else {
-            this.createVote(`grant voting power to ${address}`, `Should we grant ${address} voting power?`, new Date().getTime() + this.#votingDuration, '#grantVotingPower', [address]);
+            this.createVote(`grant voting power to ${address}`, `Should we grant ${address} voting power?`, new Date().getTime() + this.votingDuration, '#grantVotingPower', [address]);
         }
     }
     revokeVotingPower(address, voteId) {
-        if (!this.canVote(msg.sender))
+        if (!this._canVote())
             throw new Error('not a allowed to vote');
-        if (this.#voters.length === 1 && address === msg.sender && !this.#votingDisabled)
+        if (this.#voters.length === 1 && address === msg.sender && !this.votingDisabled)
             throw new Error('only one voter left, disable voting before making this contract voteless');
         if (this.#voters.length === 1)
             this.#revokeVotingPower(address);
         else {
-            this.createVote(`revoke voting power for ${address}`, `Should we revoke ${address} it's voting power?`, new Date().getTime() + this.#votingDuration, '#revokeVotingPower', [address]);
-        }
-    }
-    sync() {
-        for (const vote of this.inProgress) {
-            if (vote.endTime < new Date().getTime())
-                this.#endVoting(vote.id);
+            this.createVote(`revoke voting power for ${address}`, `Should we revoke ${address} it's voting power?`, new Date().getTime() + this.votingDuration, '#revokeVotingPower', [address]);
         }
     }
 }

package/exports/public-voting.js

@@ -1,113 +1,5 @@
-import ContractCreator from './contract-creator.js';
-
-class Voting extends ContractCreator {
-    #votes = {};
-    #votingDisabled = false;
-    #votingDuration = 172800000;
-    constructor(state) {
-        super(state);
-        if (state) {
-            this.#votes = state.votes;
-            this.#votingDisabled = state.votingDisabled;
-            this.#votingDuration = state.votingDuration;
-        }
-    }
-    get votes() {
-        return { ...this.#votes };
-    }
-    get votingDuration() {
-        return this.#votingDuration;
-    }
-    get votingDisabled() {
-        return this.#votingDisabled;
-    }
-    get state() {
-        return {
-            ...super.state,
-            votes: this.#votes,
-            votingDisabled: this.#votingDisabled,
-            votingDuration: this.#votingDuration
-        };
-    }
-    #canVote() {
-        // @ts-expect-error
-        return this._canVote?.();
-    }
-    #beforeVote() {
-        // @ts-expect-error
-        return this._beforeVote?.();
-    }
-    #afterVote() {
-        // @ts-expect-error
-        return this._afterVote?.();
-    }
-    /**
-     * create vote
-     * @param {string} vote
-     * @param {string} description
-     * @param {number} endTime
-     * @param {string} method function to run when agree amount is bigger
-     */
-    createVote(title, description, endTime, method, args = []) {
-        if (!this.#canVote())
-            throw new Error(`Not allowed to create a vote`);
-        const id = crypto.randomUUID();
-        this.#votes[id] = {
-            title,
-            description,
-            method,
-            endTime,
-            args
-        };
-    }
-    #endVoting(voteId) {
-        let agree = Object.values(this.#votes[voteId].results).filter((result) => result === 1);
-        let disagree = Object.values(this.#votes[voteId].results).filter((result) => result === 0);
-        if (agree.length > disagree.length && this.#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;
-        await this.#afterVote();
-    }
-    get votesInProgress() {
-        return Object.entries(this.#votes)
-            .filter(([id, vote]) => !vote.finished)
-            .map(([id, vote]) => {
-            return { ...vote, id };
-        });
-    }
-    #disableVoting() {
-        this.#votingDisabled = true;
-    }
-    disableVoting() {
-        if (!this.#canVote())
-            throw new Error('not a allowed');
-        else {
-            this.createVote(`disable voting`, `Warning this disables all voting features forever`, new Date().getTime() + this.#votingDuration, '#disableVoting', []);
-        }
-    }
-    _sync() {
-        for (const vote of this.votesInProgress) {
-            if (vote.endTime < new Date().getTime())
-                this.#endVoting(vote.id);
-        }
-    }
-}
+import { V as Voting } from './voting-xYjJlN2h.js';
+import './contract-creator.js';
 
 /**
  * allows everybody that has a balance greater or equeal then/to tokenAmountToReceive to vote

package/exports/staking.d.ts

@@ -0,0 +1,39 @@
+import Roles, { RolesState } from './roles.js';
+export declare interface TokenState extends RolesState {
+    holders: BigNumberish;
+    balances: {
+        [address: address]: BigNumberish;
+    };
+    approvals: {
+        [owner: address]: {
+            [operator: address]: BigNumberish;
+        };
+    };
+    totalSupply: BigNumberish;
+}
+export default class Token extends Roles {
+    #private;
+    constructor(name: string, symbol: string, decimals?: number, state?: TokenState);
+    /**
+     * @return {Object} {holders, balances, ...}
+     */
+    get state(): TokenState;
+    get totalSupply(): BigNumberish;
+    get name(): string;
+    get symbol(): string;
+    get holders(): TokenState['holders'];
+    get balances(): TokenState['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;
+    transfer(from: address, to: address, amount: BigNumberish): void;
+}

package/exports/token-receiver.d.ts

@@ -1,4 +1,4 @@
-import { IPublicVoting } from './voting/interfaces/i-public-voting.js';
+import { IVoting } from './voting/interfaces/i-voting.js';
 import PublicVoting, { PublicVotingState } from './voting/public-voting.js';
 export interface TokenReceiverState extends PublicVotingState {
     tokenToReceive: address;
@@ -6,7 +6,7 @@ export interface TokenReceiverState extends PublicVotingState {
     tokenAmountToReceive: typeof BigNumber;
     voteType: 'burn' | 'transfer';
 }
-export default class TokenReceiver extends PublicVoting implements IPublicVoting {
+export default class TokenReceiver extends PublicVoting implements IVoting {
     #private;
     constructor(tokenToReceive: address, tokenAmountToReceive: typeof BigNumber, burns: boolean, state?: TokenReceiverState);
     get tokenToReceive(): string;

package/exports/token-receiver.js

@@ -1,4 +1,5 @@
 import PublicVoting from './public-voting.js';
+import './voting-xYjJlN2h.js';
 import './contract-creator.js';
 
 class TokenReceiver extends PublicVoting {
@@ -57,7 +58,7 @@ class TokenReceiver extends PublicVoting {
         return msg.staticCall(this.tokenToReceive, 'transfer', [msg.sender, this.tokenReceiver, this.tokenAmountToReceive]);
     }
     async _beforeVote() {
-        await this.#beforeVote();
+        return this.#beforeVote();
     }
     /**
      * check if sender can pay

package/exports/token.d.ts

@@ -1,5 +1,8 @@
 import Roles, { RolesState } from './roles.js';
 export declare interface TokenState extends RolesState {
+    name: string;
+    symbol: string;
+    decimals: number;
     holders: BigNumberish;
     balances: {
         [address: address]: BigNumberish;

package/exports/token.js

@@ -25,6 +25,7 @@ class Token extends Roles {
     #approvals = {};
     #decimals = 18;
     #totalSupply = BigNumber['from'](0);
+    #stakingContract;
     // this.#privateField2 = 1
     constructor(name, symbol, decimals = 18, state) {
         if (!name)
@@ -37,6 +38,9 @@ class Token extends Roles {
             this.#approvals = restoreApprovals(state.approvals);
             this.#holders = BigNumber['from'](state.holders);
             this.#totalSupply = BigNumber['from'](state.totalSupply);
+            this.#name = name;
+            this.#symbol = symbol;
+            this.#decimals = decimals;
         }
         else {
             this.#name = name;
@@ -53,6 +57,9 @@ class Token extends Roles {
     get state() {
         return {
             ...super.state,
+            name: this.#name,
+            symbol: this.#symbol,
+            decimals: this.#decimals,
             holders: this.holders,
             balances: this.balances,
             approvals: { ...this.#approvals },
@@ -87,10 +94,13 @@ class Token extends Roles {
         this.#increaseBalance(to, amount);
     }
     burn(from, amount) {
-        if (!this.hasRole(msg.sender, 'BURN'))
+        if (!this.hasRole(msg.sender, 'BURN') || msg.sender !== from)
             throw new Error('not allowed');
-        this.#totalSupply = this.#totalSupply.sub(amount);
-        this.#decreaseBalance(from, amount);
+        const total = this.#totalSupply.sub(amount);
+        if (total.gte(0)) {
+            this.#totalSupply = total;
+            this.#decreaseBalance(from, amount);
+        }
     }
     #beforeTransfer(from, to, amount) {
         if (!this.#balances[from] || this.#balances[from] < amount)

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

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

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

@@ -1,33 +1,15 @@
-import ContractCreator, { ContractCreatorState } from '../contract-creator.js';
-import { VoteResult, VoteView, VotingState } from './types.js';
+import { ContractCreatorState } from '../contract-creator.js';
+import { IVoting } from './interfaces/i-voting.js';
+import { VotingState } from './types.js';
+import Voting from './voting.js';
 export interface PrivateVotingState extends VotingState, ContractCreatorState {
-    voters: any;
+    voters: address[];
 }
-export default class PrivateVoting extends ContractCreator {
+export default class PrivateVoting extends Voting implements IVoting {
     #private;
     constructor(state: PrivateVotingState);
-    get votes(): {
-        [x: string]: import("./types.js").Vote;
-    };
-    get voters(): any;
-    get votingDisabled(): boolean;
-    /**
-     *
-     */
     get state(): PrivateVotingState;
-    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;
+    _canVote(): boolean;
     grantVotingPower(address: address, voteId: string): void;
     revokeVotingPower(address: address, voteId: string): void;
-    sync(): void;
 }

package/exports/voting/voting.d.ts

@@ -1,16 +1,16 @@
 import ContractCreator, { ContractCreatorState } from '../contract-creator.js';
-import { Vote, VoteResult, VotingState } from './types.js';
-export declare interface _VotingState extends VotingState, ContractCreatorState {
+import { Vote, VoteResult, VotingState as _VotingState } from './types.js';
+export declare interface VotingState extends _VotingState, ContractCreatorState {
 }
 export default class Voting extends ContractCreator {
     #private;
-    constructor(state: any);
+    constructor(state: VotingState);
     get votes(): {
         [x: string]: Vote;
     };
     get votingDuration(): number;
     get votingDisabled(): boolean;
-    get state(): _VotingState;
+    get state(): VotingState;
     /**
      * create vote
      * @param {string} vote
@@ -34,5 +34,5 @@ export default class Voting extends ContractCreator {
         enoughVotes?: boolean;
     }[];
     disableVoting(): void;
-    _sync(): void;
+    sync(): void;
 }

package/exports/voting-C0KVNQO3.js

@@ -0,0 +1,112 @@
+import ContractCreator from './contract-creator.js';
+
+class Voting extends ContractCreator {
+    #votes = {};
+    #votingDisabled = false;
+    #votingDuration = 172800000;
+    constructor(state) {
+        super(state);
+        if (state) {
+            this.#votes = state.votes;
+            this.#votingDisabled = state.votingDisabled;
+            this.#votingDuration = state.votingDuration;
+        }
+    }
+    get votes() {
+        return { ...this.#votes };
+    }
+    get votingDuration() {
+        return this.#votingDuration;
+    }
+    get votingDisabled() {
+        return this.#votingDisabled;
+    }
+    get state() {
+        return {
+            ...super.state,
+            votes: this.#votes,
+            votingDisabled: this.#votingDisabled,
+            votingDuration: this.#votingDuration
+        };
+    }
+    #canVote() {
+        // @ts-expect-error
+        return this._canVote?.();
+    }
+    #beforeVote() {
+        // @ts-expect-error
+        return this._beforeVote?.();
+    }
+    #afterVote() {
+        // @ts-expect-error
+        return this._afterVote?.();
+    }
+    /**
+     * create vote
+     * @param {string} vote
+     * @param {string} description
+     * @param {number} endTime
+     * @param {string} method function to run when agree amount is bigger
+     */
+    createVote(title, description, endTime, method, args = []) {
+        if (!this.#canVote())
+            throw new Error(`Not allowed to create a vote`);
+        const id = crypto.randomUUID();
+        this.#votes[id] = {
+            title,
+            description,
+            method,
+            endTime,
+            args
+        };
+    }
+    #endVoting(voteId) {
+        let agree = Object.values(this.#votes[voteId].results).filter((result) => result === 1);
+        let disagree = Object.values(this.#votes[voteId].results).filter((result) => result === 0);
+        if (agree.length > disagree.length)
+            this[this.#votes[voteId].method](...this.#votes[voteId].args);
+        this.#votes[voteId].finished = true;
+    }
+    async vote(voteId, vote) {
+        vote = Number(vote);
+        if (vote !== 0 && vote !== 0.5 && vote !== 1)
+            throw new Error(`invalid vote value ${vote}`);
+        if (!this.#votes[voteId])
+            throw new Error(`Nothing found for ${voteId}`);
+        const ended = new Date().getTime() > this.#votes[voteId].endTime;
+        if (ended && !this.#votes[voteId].finished)
+            this.#endVoting(voteId);
+        if (ended)
+            throw new Error('voting already ended');
+        if (!this.#canVote())
+            throw new Error(`Not allowed to vote`);
+        await this.#beforeVote();
+        this.#votes[voteId][msg.sender] = vote;
+        await this.#afterVote();
+    }
+    get votesInProgress() {
+        return Object.entries(this.#votes)
+            .filter(([id, vote]) => !vote.finished)
+            .map(([id, vote]) => {
+            return { ...vote, id };
+        });
+    }
+    #disableVoting() {
+        this.#votingDisabled = true;
+    }
+    disableVoting() {
+        if (!this.#canVote())
+            throw new Error('not a allowed');
+        else {
+            this.createVote(`disable voting`, `Warning this disables all voting features forever`, new Date().getTime() + this.#votingDuration, '#disableVoting', []);
+        }
+    }
+    _sync() {
+        for (const vote of this.votesInProgress) {
+            if (vote.endTime < new Date().getTime())
+                this.#endVoting(vote.id);
+        }
+    }
+}
+
+export { Voting as V };