@leofcoin/standards 0.2.16 → 0.3.0

package/exports/token-receiver.js

@@ -1,6 +1,5 @@
 import PublicVoting from './public-voting.js';
-import './voting-xYjJlN2h.js';
-import './contract-creator.js';
+import './meta-D7uruGOw.js';
 
 class TokenReceiver extends PublicVoting {
     #tokenToReceive;
@@ -42,7 +41,9 @@ class TokenReceiver extends PublicVoting {
         };
     }
     async #canVote() {
-        const amount = (await msg.staticCall(this.#tokenToReceive, 'balanceOf', [msg.sender]));
+        const amount = (await msg.staticCall(this.#tokenToReceive, 'balanceOf', [
+            msg.sender
+        ]));
         return amount >= this.#tokenAmountToReceive;
     }
     /**
@@ -54,11 +55,17 @@ class TokenReceiver extends PublicVoting {
     }
     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]);
+            return msg.staticCall(this.tokenToReceive, 'burn', [
+                this.tokenAmountToReceive
+            ]);
+        return msg.staticCall(this.tokenToReceive, 'transfer', [
+            msg.sender,
+            this.tokenReceiver,
+            this.tokenAmountToReceive
+        ]);
     }
     async _beforeVote() {
-        return this.#beforeVote();
+        await this.#beforeVote();
     }
     /**
      * check if sender can pay
@@ -76,11 +83,9 @@ class TokenReceiver extends PublicVoting {
      * @returns {boolean} promise
      */
     async _burnTokenToReceive() {
-        return msg.staticCall(this.#tokenToReceive, 'burn', [this.#tokenAmountToReceive]);
-    }
-    async _canPay() {
-        const amount = await msg.call(this.#tokenToReceive, 'balance', []);
-        return amount.gte(this.tokenAmountToReceive);
+        return msg.staticCall(this.#tokenToReceive, 'burn', [
+            this.#tokenAmountToReceive
+        ]);
     }
     #changeTokenToReceive(address) {
         this.#tokenToReceive = address;
@@ -92,7 +97,11 @@ class TokenReceiver extends PublicVoting {
         this.#voteType = type;
     }
     #getTokensOut(amount, receiver) {
-        return msg.call(this.#tokenReceiver, 'transfer', [this.#tokenReceiver, receiver, amount]);
+        return msg.call(this.#tokenReceiver, 'transfer', [
+            this.#tokenReceiver,
+            receiver,
+            amount
+        ]);
     }
     async changeVoteType(type) {
         if (!this.#canVote())
@@ -118,12 +127,14 @@ class TokenReceiver extends PublicVoting {
         }
     }
     #balance() {
-        return msg.staticCall(this.#tokenToReceive, 'balanceOf', [this.#tokenReceiver]);
+        return msg.staticCall(this.#tokenToReceive, 'balanceOf', [
+            this.#tokenReceiver
+        ]);
     }
     async changeTokenToReceive() {
         if (!this.#canVote())
             throw new Error('not a allowed');
-        if ((await this.#balance()) > 0n && this.#voteType === 'transfer')
+        if ((await this.#balance()) !== 0n && 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/exports/token.d.ts

@@ -1,36 +1,23 @@
-/// <reference types="@leofcoin/types/global" />
-import Roles, { RolesState } from './roles.js';
-export declare interface TokenState extends RolesState {
-    name: string;
-    symbol: string;
-    decimals: number;
-    holders: bigint;
-    balances: {
-        [address: address]: bigint;
-    };
-    approvals: {
-        [owner: address]: {
-            [operator: address]: bigint;
-        };
-    };
-    totalSupply: bigint;
-    maxSupply: bigint;
-}
+import Roles from './roles.js';
+import { TokenState } from './types.js';
 export default class Token extends Roles {
     #private;
     constructor(name: string, symbol: string, decimals?: number, state?: TokenState);
     /**
      * @return {Object} {holders, balances, ...}
      */
-    get state(): TokenState;
-    get maxSupply(): TokenState['maxSupply'];
-    get totalSupply(): TokenState['totalSupply'];
-    get name(): TokenState['name'];
-    get symbol(): TokenState['symbol'];
-    get holders(): TokenState['holders'];
-    get balances(): TokenState['balances'];
-    get approvals(): TokenState['approvals'];
-    get decimals(): TokenState['decimals'];
+    get state(): {};
+    get totalSupply(): bigint;
+    get name(): string;
+    get symbol(): string;
+    get holders(): {};
+    get balances(): {};
+    get approvals(): {
+        [owner: string]: {
+            [operator: string]: bigint;
+        };
+    };
+    get decimals(): number;
     mint(to: address, amount: bigint): void;
     burn(from: address, amount: bigint): void;
     balance(): any;

package/exports/token.js

@@ -1,6 +1,6 @@
 import { restoreBalances, restoreApprovals } from './helpers.js';
 import Roles from './roles.js';
-import './contract-creator.js';
+import './meta-D7uruGOw.js';
 
 class Token extends Roles {
     /**
@@ -14,7 +14,7 @@ class Token extends Roles {
     /**
      * uint
      */
-    #holders = BigInt(0);
+    #holders = 0n;
     /**
      * Object => Object => uint
      */
@@ -24,9 +24,7 @@ class Token extends Roles {
      */
     #approvals = {};
     #decimals = 18;
-    #totalSupply = BigInt(0);
-    #maxSupply = BigInt(0);
-    #stakingContract;
+    #totalSupply = 0n;
     constructor(name, symbol, decimals = 18, state) {
         if (!name)
             throw new Error(`name undefined`);
@@ -38,10 +36,6 @@ class Token extends Roles {
             this.#approvals = restoreApprovals(state.approvals);
             this.#holders = BigInt(state.holders);
             this.#totalSupply = BigInt(state.totalSupply);
-            this.#name = name;
-            this.#symbol = symbol;
-            this.#decimals = decimals;
-            this.#maxSupply = BigInt(state.maxSupply);
         }
         else {
             this.#name = name;
@@ -52,26 +46,18 @@ class Token extends Roles {
     // enables snapshotting
     // needs dev attention so nothing breaks after snapshot happens
     // iow everything that is not static needs to be included in the stateObject
-    // TODO: implement snapshotting test
     /**
      * @return {Object} {holders, balances, ...}
      */
     get state() {
         return {
             ...super.state,
-            name: this.#name,
-            symbol: this.#symbol,
-            decimals: this.#decimals,
             holders: this.holders,
             balances: this.balances,
             approvals: { ...this.#approvals },
-            totalSupply: this.totalSupply,
-            maxSupply: this.#maxSupply
+            totalSupply: this.totalSupply
         };
     }
-    get maxSupply() {
-        return this.#maxSupply;
-    }
     get totalSupply() {
         return this.#totalSupply;
     }
@@ -95,35 +81,15 @@ class Token extends Roles {
     }
     mint(to, amount) {
         if (!this.hasRole(msg.sender, 'MINT'))
-            throw new Error('mint role required');
-        const supply = this.#totalSupply + amount;
-        if (this.#maxSupply === 0n) {
-            this.#totalSupply = supply;
-            this.#increaseBalance(to, amount);
-        }
-        else {
-            if (supply <= this.#maxSupply) {
-                this.#totalSupply = supply;
-                this.#increaseBalance(to, amount);
-            }
-            else {
-                throw new Error('amount exceeds max supply');
-            }
-        }
+            throw new Error('not allowed');
+        this.#totalSupply = this.#totalSupply + amount;
+        this.#increaseBalance(to, amount);
     }
     burn(from, amount) {
-        if (!this.hasRole(msg.sender, 'BURN') && msg.sender !== from)
-            throw new Error('not the owner or burn role required');
-        if (this.#balances[from] < amount)
-            throw new Error('amount exceeds balance');
-        const total = this.#totalSupply - amount;
-        if (total >= 0) {
-            this.#totalSupply = total;
-            this.#decreaseBalance(from, amount);
-        }
-        else {
-            throw new Error('amount exceeds total supply');
-        }
+        if (!this.hasRole(msg.sender, 'BURN'))
+            throw new Error('not allowed');
+        this.#totalSupply = this.#totalSupply - amount;
+        this.#decreaseBalance(from, amount);
     }
     #beforeTransfer(from, to, amount) {
         if (!this.#balances[from] || this.#balances[from] < amount)
@@ -137,14 +103,14 @@ class Token extends Roles {
     }
     #increaseBalance(address, amount) {
         if (!this.#balances[address])
-            this.#balances[address] = BigInt(0);
+            this.#balances[address] = 0n;
         const previousBalance = this.#balances[address];
-        this.#balances[address] = this.#balances[address] += amount;
+        this.#balances[address] = this.#balances[address] + amount;
         this.#updateHolders(address, previousBalance);
     }
     #decreaseBalance(address, amount) {
         const previousBalance = this.#balances[address];
-        this.#balances[address] = this.#balances[address] -= amount;
+        this.#balances[address] = this.#balances[address] - amount;
         this.#updateHolders(address, previousBalance);
     }
     balance() {

package/exports/types.d.ts

@@ -0,0 +1,21 @@
+export interface MetaState {
+    creator: address;
+    createdAt: bigint;
+}
+export declare interface RolesState extends MetaState {
+    roles: {
+        [index: string]: address[];
+    };
+}
+export declare interface TokenState extends RolesState {
+    holders: bigint;
+    balances: {
+        [address: address]: bigint;
+    };
+    approvals: {
+        [owner: address]: {
+            [operator: address]: bigint;
+        };
+    };
+    totalSupply: bigint;
+}

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

@@ -1,16 +1,113 @@
-/// <reference types="@leofcoin/types/global" />
-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: address[];
-}
-export default class PrivateVoting extends Voting implements IVoting {
+import Meta from '../meta.js';
+import { PrivateVotingState, VoteResult, VoteView } from './types.js';
+export default class PrivateVoting extends Meta {
     #private;
     constructor(state: PrivateVotingState);
-    get state(): PrivateVotingState;
-    _canVote(): boolean;
+    get votes(): {
+        [x: string]: import("./types.js").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

@@ -1,11 +1,48 @@
-import { ContractCreatorState } from '../contract-creator.js';
-import { VotingState } from './types.js';
-import Voting from './voting.js';
-export declare interface PublicVotingState extends VotingState, ContractCreatorState {
-}
+import Meta from '../meta.js';
+import { VotingState, VoteResult } from './types.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
  */
-export default class PublicVoting extends Voting {
-    constructor(state: PublicVotingState);
+export default class PublicVoting extends Meta {
+    #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

@@ -1,3 +1,14 @@
+import { MetaState } from '../types.js';
+export interface VotingState extends MetaState {
+    votes: {
+        [id: string]: Vote;
+    };
+    votingDisabled: boolean;
+    votingDuration: number;
+}
+export interface PrivateVotingState extends VotingState {
+    voters: address[];
+}
 export type VoteResult = 0 | 0.5 | 1;
 export type Vote = {
     title: string;
@@ -11,13 +22,6 @@ export type Vote = {
     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,6 +1,6 @@
 {
   "name": "@leofcoin/standards",
-  "version": "0.2.16",
+  "version": "0.3.0",
   "description": "Contract standards",
   "type": "module",
   "exports": {
@@ -24,19 +24,13 @@
       "import": "./exports/private-voting.js",
       "types": "./exports/private-voting.d.ts"
     },
-    "./contract-creator": {
-      "import": "./exports/contract-creator.js",
-      "types": "./exports/contract-creator.d.ts"
-    },
     "./token-receiver": {
       "import": "./exports/token-receiver.js",
       "types": "./exports/token-receiver.d.ts"
     },
-    "./interfaces/i-voting": {
-      "types": "./exports/voting/interfaces/i-voting.d.ts"
-    },
-    "./interfaces/i-token": {
-      "types": "./exports/interfaces/i-token.d.ts"
+    "./interfaces/i-public-voting": {
+      "import": "./exports/i-public-voting.js",
+      "types": "./exports/i-public-voting.d.ts"
     },
     "./helpers": {
       "import": "./exports/helpers.js",
@@ -45,13 +39,13 @@
     "./token.js": "./exports/token.js",
     "./roles.js": "./exports/roles.js",
     "./public-voting.js": "./exports/public-voting.js",
+    "./interfaces/i-public-voting.js": "./exports/i-public-voting.js",
     "./private-voting.js": "./exports/private-voting.js",
-    "./contract-creator.js": "./exports/contract-creator.js",
     "./helpers.js": "./exports/helpers.js"
   },
   "scripts": {
     "build": "rollup -c",
-    "test": "mocha --require ts-node/register test/**/*.ts"
+    "test": "node --test ./test/**/*.js"
   },
   "repository": {
     "type": "git",
@@ -65,11 +59,9 @@
   },
   "homepage": "https://github.com/ArteonToken/standards#readme",
   "devDependencies": {
-    "@leofcoin/types": "^1.0.17",
-    "@rollup/plugin-typescript": "^11.1.6",
-    "chai": "^5.1.1",
-    "mocha": "^10.7.3",
-    "rollup": "^4.22.1",
-    "tslib": "^2.7.0"
+    "@leofcoin/global-types": "^1.0.2",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "rollup": "^4.54.0",
+    "tslib": "^2.8.1"
   }
 }

package/rollup.config.js

@@ -1,28 +1,28 @@
-import typescript from '@rollup/plugin-typescript'
-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',
-      'src/voting/public-voting.ts',
-      'src/voting/private-voting.ts',
-      'src/helpers.ts',
-      'src/contract-creator.ts',
-      'src/token-receiver.ts'
-    ],
-    output: {
-      dir: './exports',
-      format: 'es'
-    },
-    plugins: [typescript()]
-  }
-]
+import typescript from '@rollup/plugin-typescript'
+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',
+      'src/voting/public-voting.ts',
+      'src/voting/interfaces/i-public-voting.ts',
+      'src/voting/private-voting.ts',
+      'src/helpers.ts',
+      'src/token-receiver.ts'
+    ],
+    output: {
+      dir: './exports',
+      format: 'es'
+    },
+    plugins: [typescript()]
+  }
+]

package/src/helpers.ts

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

package/src/index.ts

@@ -1,7 +1,8 @@
-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'
+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'
+
+export * from './helpers.js'