@leofcoin/standards 0.2.16 → 0.3.0

package/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=LF
+# Auto detect text files and perform LF normalization
+* text=LF

package/.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [22.x, latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build project
+        run: npm run build
+
+      - name: Run tests
+        run: npm test

package/.prettierrc

@@ -1,8 +1,8 @@
-{
-  "tabWidth": 2,
-  "semi": false,
-  "singleQuote": true,
-  "printWidth": 120,
-  "trailingComma": "none",
-  "bracketSameLine": true
-}
+{
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": true,
+  "printWidth": 80,
+  "trailingComma": "none",
+  "bracketSameLine": true
+}

package/CHANGELOG.md

@@ -1,10 +1,23 @@
 # @leofcoin/standards
 
-## 0.2.2
+## Unreleased
 
-### Patch Changes
+### Changed
+
+- Refactored TokenReceiver to use native `bigint` instead of `BigNumber`
+- Updated comparison operators to use native BigInt comparisons (`>=`, `>`, `===`)
+
+### Added
+
+- GitHub Actions workflow for automated testing across Node.js versions 18.x, 20.x, 22.x
+- Test status badge in README
+- Comprehensive unit tests for helpers, roles, token, and voting modules
+- Meta base class for state management
+
+### Fixed
 
-- e8609a5: Fix types & build
+- Test script glob pattern in package.json
+- Build step added to CI workflow for proper test execution
 
 ## 0.2.1
 

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 ArteonToken
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2022 ArteonToken
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,23 +1,25 @@
-# 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'
-
-class myCoolToken extends Token {
-  constructor(state) {
-    super('myCoolToken', 'MCT', 18, state)
-  }
-}
-```
+# standards
+
+[![Tests](https://github.com/leofcoin/standards/actions/workflows/test.yml/badge.svg)](https://github.com/leofcoin/standards/actions/workflows/test.yml)
+
+> 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'
+
+class myCoolToken extends Token {
+  constructor(state) {
+    super('myCoolToken', 'MCT', 18, state)
+  }
+}
+```

package/exports/helpers.js

@@ -1,4 +1,4 @@
-// when state is stored it get encoded as a string to  so we need to reformat balances back to BigInt's
+// when state is stored it get encoded as a string to  so we need to reformat balances back to BigInts
 const restoreBalances = (balances) => {
     const _balances = {};
     for (const address in balances) {

package/exports/i-public-voting.js

@@ -0,0 +1 @@
+

package/exports/index.d.ts

@@ -1,5 +1,6 @@
-export { default as Token } from './token.js';
+export { default as Meta } from './meta.js';
 export { default as Roles } from './roles.js';
+export { default as Token } from './token.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';

package/exports/index.js

@@ -1,8 +1,7 @@
-export { default as Token } from './token.js';
+export { M as Meta } from './meta-D7uruGOw.js';
 export { default as Roles } from './roles.js';
+export { default as Token } from './token.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';
-import './contract-creator.js';
-import './voting-xYjJlN2h.js';

package/exports/meta-D7uruGOw.js

@@ -0,0 +1,28 @@
+class Meta {
+    #creator;
+    #createdAt = BigInt(Date.now());
+    constructor(state) {
+        if (state) {
+            this.#creator = state.creator;
+            this.#createdAt = state.createdAt;
+        }
+        else {
+            this.#creator = msg.sender;
+            this.#createdAt = BigInt(Date.now());
+        }
+    }
+    /**
+     * get state object for snapshotting
+     */
+    get state() {
+        return { creator: this.#creator, createdAt: this.#createdAt };
+    }
+    get creator() {
+        return this.#creator;
+    }
+    get createdAt() {
+        return this.#createdAt;
+    }
+}
+
+export { Meta as M };

package/exports/meta.d.ts

@@ -0,0 +1,11 @@
+import { MetaState } from './types.js';
+export default class Meta {
+    #private;
+    constructor(state?: MetaState);
+    /**
+     * get state object for snapshotting
+     */
+    get state(): {};
+    get creator(): address;
+    get createdAt(): bigint;
+}

package/exports/private-voting.js

@@ -1,25 +1,101 @@
-import { V as Voting } from './voting-xYjJlN2h.js';
-import './contract-creator.js';
+import { M as Meta } from './meta-D7uruGOw.js';
 
-class PrivateVoting extends Voting {
+class PrivateVoting extends Meta {
     #voters;
+    #votes;
+    #votingDisabled;
     constructor(state) {
         super(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 {
             ...super.state,
-            voters: this.#voters
+            voters: this.#voters,
+            votes: this.#votes,
+            votingDisabled: this.#votingDisabled
         };
     }
-    _canVote() {
-        return this.#voters.includes(msg.sender);
+    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);
@@ -27,22 +103,39 @@ class PrivateVoting extends Voting {
     #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())
+        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() + this.votingDuration, '#grantVotingPower', [address]);
+            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())
+        if (!this.canVote(msg.sender))
             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]);
+            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/exports/public-voting.js

@@ -1,12 +1,111 @@
-import { V as Voting } from './voting-xYjJlN2h.js';
-import './contract-creator.js';
+import { M as Meta } from './meta-D7uruGOw.js';
 
 /**
- * allows everybody that has a balance greater or equeal then/to tokenAmountToReceive to vote
+ * allows everybody that has a balance greater or equal to tokenAmountToReceive to vote
  */
-class PublicVoting extends Voting {
+class PublicVoting extends Meta {
+    #votes;
+    #votingDisabled;
+    #votingDuration = 172800000;
     constructor(state) {
         super(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 {
+            ...super.state,
+            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);
+        }
     }
 }
 

package/exports/roles.d.ts

@@ -1,17 +1,12 @@
-/// <reference types="@leofcoin/types/global" />
-import ContractCreator, { ContractCreatorState } from './contract-creator.js';
-export interface RolesState extends ContractCreatorState {
-    roles: {
-        [index: string]: address[];
-    };
-}
-export default class Roles extends ContractCreator {
+import Meta from './meta.js';
+import { RolesState } from './types.js';
+export default class Roles extends Meta {
     #private;
-    constructor(state: any);
+    constructor(state?: RolesState);
     /**
      *
      */
-    get state(): RolesState;
+    get state(): {};
     get roles(): {};
     /**
      * @param {address} address

package/exports/roles.js

@@ -1,6 +1,6 @@
-import ContractCreator from './contract-creator.js';
+import { M as Meta } from './meta-D7uruGOw.js';
 
-class Roles extends ContractCreator {
+class Roles extends Meta {
     /**
      * Object => Array
      */
@@ -11,13 +11,9 @@ class Roles extends ContractCreator {
     };
     constructor(state) {
         super(state);
-        // allow devs to set their own roles but always keep the default ones included
-        // also allows roles to be loaded from the stateStore
-        // carefull when including the roles make sure to add the owner
-        // because no roles are granted by default when using custom roles
         if (state?.roles) {
             if (state.roles instanceof Object) {
-                this.#roles = { ...state.roles, ...this.#roles };
+                this.#roles = { ...state.roles };
             }
             else {
                 throw new TypeError(`expected roles to be an object`);
@@ -32,7 +28,10 @@ class Roles extends ContractCreator {
      *
      */
     get state() {
-        return { ...super.state, roles: this.roles };
+        return {
+            ...super.state,
+            roles: this.roles
+        };
     }
     get roles() {
         return { ...this.#roles };

package/exports/token-receiver.d.ts

@@ -1,13 +1,13 @@
-/// <reference types="@leofcoin/types/global" />
-import { IVoting } from './voting/interfaces/i-voting.js';
-import PublicVoting, { PublicVotingState } from './voting/public-voting.js';
-export interface TokenReceiverState extends PublicVotingState {
+import { IPublicVoting } from './voting/interfaces/i-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: bigint;
     voteType: 'burn' | 'transfer';
 }
-export default class TokenReceiver extends PublicVoting implements IVoting {
+export default class TokenReceiver extends PublicVoting implements IPublicVoting {
     #private;
     constructor(tokenToReceive: address, tokenAmountToReceive: bigint, burns: boolean, state?: TokenReceiverState);
     get tokenToReceive(): string;
@@ -23,7 +23,6 @@ export default class TokenReceiver extends PublicVoting implements IVoting {
         };
         votingDisabled: boolean;
         votingDuration: number;
-        contractCreator: string;
     };
     /**
      * check if sender can pay
@@ -41,7 +40,6 @@ export default class TokenReceiver extends PublicVoting implements IVoting {
      * @returns {boolean} promise
      */
     _burnTokenToReceive(): Promise<boolean>;
-    _canPay(): Promise<any>;
     changeVoteType(type: TokenReceiverState['voteType']): Promise<void>;
     getTokensOut(amount: bigint, receiver: address): void;
     changeTokenAmountToReceive(): void;