@leofcoin/standards 0.2.15 → 0.3.0

package/test/roles.js

@@ -0,0 +1,186 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import Roles from './../exports/roles.js'
+
+test('Roles - constructor initializes with provided roles', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: {
+      OWNER: [],
+      MINT: [],
+      BURN: []
+    }
+  }
+  const roles = new Roles(state)
+
+  assert(roles.roles)
+  assert.deepEqual(roles.roles.OWNER, [])
+  assert.deepEqual(roles.roles.MINT, [])
+  assert.deepEqual(roles.roles.BURN, [])
+})
+
+test('Roles - constructor with state initializes custom roles', () => {
+  const state = {
+    creator: '0x1',
+    roles: {
+      admin: ['0x1', '0x2'],
+      user: ['0x3']
+    }
+  }
+
+  const roles = new Roles(state)
+
+  assert.deepEqual(roles.roles.admin, ['0x1', '0x2'])
+  assert.deepEqual(roles.roles.user, ['0x3'])
+})
+
+test('Roles - constructor throws when roles is not an object', () => {
+  const state = {
+    creator: '0x1',
+    roles: 'invalid'
+  }
+
+  assert.throws(() => {
+    new Roles(state)
+  }, /expected roles to be an object/)
+})
+
+test('Roles - hasRole returns true for address with role', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: {
+      OWNER: ['0xabc'],
+      MINT: ['0xdef', '0x123'],
+      BURN: []
+    }
+  }
+  const roles = new Roles(state)
+
+  assert.equal(roles.hasRole('0xabc', 'OWNER'), true)
+  assert.equal(roles.hasRole('0xdef', 'MINT'), true)
+  assert.equal(roles.hasRole('0x123', 'MINT'), true)
+})
+
+test('Roles - hasRole returns false for address without role', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: {
+      OWNER: ['0xabc'],
+      MINT: [],
+      BURN: []
+    }
+  }
+  const roles = new Roles(state)
+
+  assert.equal(roles.hasRole('0xdef', 'OWNER'), false)
+  assert.equal(roles.hasRole('0xabc', 'MINT'), false)
+  assert.equal(roles.hasRole('0xabc', 'BURN'), false)
+})
+
+test('Roles - hasRole returns false for non-existent role', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: {
+      OWNER: ['0xabc'],
+      MINT: [],
+      BURN: []
+    }
+  }
+  const roles = new Roles(state)
+
+  assert.equal(roles.hasRole('0xabc', 'ADMIN'), false)
+  assert.equal(roles.hasRole('0xabc', 'NON_EXISTENT'), false)
+})
+
+test('Roles - roles getter returns copy of roles', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: {
+      OWNER: ['0x1', '0x2'],
+      MINT: ['0x3'],
+      BURN: []
+    }
+  }
+  const roles = new Roles(state)
+  const rolesObj = roles.roles
+
+  assert.deepEqual(rolesObj.OWNER, ['0x1', '0x2'])
+  assert.deepEqual(rolesObj.MINT, ['0x3'])
+  assert.deepEqual(rolesObj.BURN, [])
+})
+
+test('Roles - state getter returns complete state', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    createdAt: Date.now(),
+    roles: {
+      OWNER: ['0x1'],
+      MINT: ['0x2'],
+      BURN: []
+    }
+  }
+  const roles = new Roles(state)
+  const rolesState = roles.state
+
+  assert(rolesState.creator)
+  assert(rolesState.createdAt)
+  assert(rolesState.roles)
+  assert.deepEqual(rolesState.roles.OWNER, ['0x1'])
+  assert.deepEqual(rolesState.roles.MINT, ['0x2'])
+})
+
+test('Roles - hasRole with multiple addresses in same role', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: {
+      OWNER: [],
+      MINT: ['0xa', '0xb', '0xc', '0xd'],
+      BURN: []
+    }
+  }
+  const roles = new Roles(state)
+
+  assert.equal(roles.hasRole('0xa', 'MINT'), true)
+  assert.equal(roles.hasRole('0xb', 'MINT'), true)
+  assert.equal(roles.hasRole('0xc', 'MINT'), true)
+  assert.equal(roles.hasRole('0xd', 'MINT'), true)
+  assert.equal(roles.hasRole('0xe', 'MINT'), false)
+})
+
+test('Roles - constructor with complex role structure', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: {
+      OWNER: ['0x1'],
+      MINT: ['0x2', '0x3'],
+      BURN: ['0x4', '0x5', '0x6'],
+      ADMIN: ['0x7'],
+      USER: ['0x8', '0x9', '0xa']
+    }
+  }
+  const roles = new Roles(state)
+
+  assert.equal(roles.hasRole('0x1', 'OWNER'), true)
+  assert.equal(roles.hasRole('0x2', 'MINT'), true)
+  assert.equal(roles.hasRole('0x3', 'MINT'), true)
+  assert.equal(roles.hasRole('0x4', 'BURN'), true)
+  assert.equal(roles.hasRole('0x7', 'ADMIN'), true)
+  assert.equal(roles.hasRole('0x8', 'USER'), true)
+  assert.equal(roles.hasRole('0x9', 'USER'), true)
+})
+
+test('Roles - hasRole is case-sensitive', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: {
+      OWNER: ['0xabc'],
+      owner: ['0xdef']
+    }
+  }
+  const roles = new Roles(state)
+
+  assert.equal(roles.hasRole('0xabc', 'OWNER'), true)
+  assert.equal(roles.hasRole('0xabc', 'owner'), false)
+  assert.equal(roles.hasRole('0xdef', 'owner'), true)
+  assert.equal(roles.hasRole('0xdef', 'OWNER'), false)
+})

package/test/token.js

@@ -0,0 +1,211 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import Token from './../exports/token.js'
+
+test('Token - constructor throws when name is undefined', () => {
+  assert.throws(() => {
+    new Token('', 'MTK', 18, {
+      creator: '0x1',
+      roles: { OWNER: [], MINT: [], BURN: [] },
+      balances: {},
+      approvals: {},
+      holders: '0',
+      totalSupply: '0'
+    })
+  }, /name undefined/)
+})
+
+test('Token - constructor throws when symbol is undefined', () => {
+  assert.throws(() => {
+    new Token('MyToken', '', 18, {
+      creator: '0x1',
+      roles: { OWNER: [], MINT: [], BURN: [] },
+      balances: {},
+      approvals: {},
+      holders: '0',
+      totalSupply: '0'
+    })
+  }, /symbol undefined/)
+})
+
+test('Token - constructor with state restores token properties', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: { '0x1': '1000', '0x2': '500' },
+    approvals: { '0x1': { '0x2': '250' } },
+    holders: '2',
+    totalSupply: '1500'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+
+  assert.equal(token.totalSupply, 1500n)
+  assert.equal(token.holders, 2n)
+})
+
+test('Token - constructor with zero balances state', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: {},
+    approvals: {},
+    holders: '0',
+    totalSupply: '0'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+
+  assert.equal(token.totalSupply, 0n)
+  assert.equal(token.holders, 0n)
+})
+
+test('Token - decimals getter returns correct value', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: {},
+    approvals: {},
+    holders: '0',
+    totalSupply: '0'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+
+  // Decimals default to 18 when state is provided
+  assert.equal(token.decimals, 18)
+})
+
+test('Token - balances getter returns copy of balances', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: { '0x1': '1000', '0x2': '500' },
+    approvals: {},
+    holders: '2',
+    totalSupply: '1500'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+  const balances = token.balances
+
+  assert.equal(balances['0x1'], 1000n)
+  assert.equal(balances['0x2'], 500n)
+})
+
+test('Token - balanceOf returns balance for specific address', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: { '0xabc': '2500', '0xdef': '750' },
+    approvals: {},
+    holders: '2',
+    totalSupply: '3250'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+
+  assert.equal(token.balanceOf('0xabc'), 2500n)
+  assert.equal(token.balanceOf('0xdef'), 750n)
+})
+
+test('Token - approvals getter returns approvals object', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: {},
+    approvals: { '0x1': { '0x2': '100', '0x3': '200' } },
+    holders: '0',
+    totalSupply: '0'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+  const approvals = token.approvals
+
+  assert.equal(approvals['0x1']['0x2'], 100n)
+  assert.equal(approvals['0x1']['0x3'], 200n)
+})
+
+test('Token - approved checks if exact amount is approved', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: {},
+    approvals: { '0xowner': { '0xoperator': '500' } },
+    holders: '0',
+    totalSupply: '0'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+
+  assert.equal(token.approved('0xowner', '0xoperator', 500n), true)
+  assert.equal(token.approved('0xowner', '0xoperator', 400n), false)
+  assert.equal(token.approved('0xowner', '0xoperator', 600n), false)
+})
+
+test('Token - state getter returns complete state object', () => {
+  const now = Date.now()
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    createdAt: now,
+    roles: { OWNER: ['0x1'], MINT: [], BURN: [] },
+    balances: { '0x1': '1000' },
+    approvals: { '0x1': { '0x2': '250' } },
+    holders: '1',
+    totalSupply: '1000'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+  const tokenState = token.state
+
+  // Verify state object has expected properties
+  assert(tokenState.creator)
+  assert(tokenState.createdAt)
+  assert.equal(tokenState.totalSupply, 1000n)
+  assert.equal(tokenState.holders, 1n)
+  assert(tokenState.balances)
+  assert(tokenState.approvals)
+})
+
+test('Token - constructor with multiple balances updates holders count', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: {
+      '0x1': '1000',
+      '0x2': '500',
+      '0x3': '250',
+      '0x4': '750'
+    },
+    approvals: {},
+    holders: '4',
+    totalSupply: '2500'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+
+  assert.equal(token.holders, 4n)
+  assert.equal(token.totalSupply, 2500n)
+})
+
+test('Token - constructor with complex approval state', () => {
+  const state = {
+    creator: '0x1234567890123456789012345678901234567890',
+    roles: { OWNER: [], MINT: [], BURN: [] },
+    balances: { '0x1': '1000', '0x2': '2000' },
+    approvals: {
+      '0x1': { '0x2': '100', '0x3': '200' },
+      '0x2': { '0x1': '500', '0x4': '300' }
+    },
+    holders: '2',
+    totalSupply: '3000'
+  }
+
+  const token = new Token('MyToken', 'MTK', 18, state)
+  const approvals = token.approvals
+
+  assert.equal(approvals['0x1']['0x2'], 100n)
+  assert.equal(approvals['0x1']['0x3'], 200n)
+  assert.equal(approvals['0x2']['0x1'], 500n)
+  assert.equal(approvals['0x2']['0x4'], 300n)
+})

package/tsconfig.json

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

package/.changeset/README.md

@@ -1,8 +0,0 @@
-# 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

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

package/exports/contract-creator.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="@leofcoin/types/global" />
-export type ContractCreatorState = {
-    contractCreator: address;
-};
-export default class ContractCreator {
-    #private;
-    constructor(state: ContractCreatorState);
-    get _contractCreator(): string;
-    get state(): ContractCreatorState;
-    get _isContractCreator(): boolean;
-}

package/exports/contract-creator.js

@@ -1,20 +0,0 @@
-class ContractCreator {
-    #creator;
-    constructor(state) {
-        if (state)
-            this.#creator = state.contractCreator;
-        else
-            this.#creator = msg.sender;
-    }
-    get _contractCreator() {
-        return this.#creator;
-    }
-    get state() {
-        return { contractCreator: this.#creator };
-    }
-    get _isContractCreator() {
-        return msg.sender === this.#creator;
-    }
-}
-
-export { ContractCreator as default };

package/exports/lock.d.ts

@@ -1,37 +0,0 @@
-/// <reference types="@leofcoin/types/global" />
-import { RolesState } from './roles.js';
-import { IVoting } from './voting/interfaces/i-voting.js';
-import PublicVoting from './voting/public-voting.js';
-export declare interface LockState extends RolesState {
-    holders: bigint;
-    balances: {
-        [address: address]: bigint;
-    };
-    totalSupply: bigint;
-}
-export default class Lock extends PublicVoting implements IVoting {
-    #private;
-    constructor(name: string, symbol: string, decimals?: number, state?: LockState);
-    /**
-     * @return {Object} {holders, balances, ...}
-     */
-    get state(): LockState;
-    get totalSupply(): bigint;
-    get name(): string;
-    get symbol(): string;
-    get holders(): LockState['holders'];
-    get balances(): LockState['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;
-    balanceOf(address: address): bigint;
-    setApproval(operator: address, amount: bigint): void;
-    approved(owner: address, operator: address, amount: bigint): boolean;
-    transfer(from: address, to: address, amount: bigint): void;
-}

package/exports/staking.d.ts

@@ -1,40 +0,0 @@
-/// <reference types="@leofcoin/types/global" />
-import Roles, { RolesState } from './roles.js';
-export declare interface TokenState extends RolesState {
-    holders: bigint;
-    balances: {
-        [address: address]: bigint;
-    };
-    approvals: {
-        [owner: address]: {
-            [operator: address]: bigint;
-        };
-    };
-    totalSupply: bigint;
-}
-export default class Staking extends Roles {
-    #private;
-    constructor(name: string, symbol: string, decimals?: number, state?: TokenState);
-    /**
-     * @return {Object} {holders, balances, ...}
-     */
-    get state(): TokenState;
-    get totalSupply(): bigint;
-    get name(): string;
-    get symbol(): string;
-    get holders(): TokenState['holders'];
-    get balances(): TokenState['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;
-    balanceOf(address: address): bigint;
-    setApproval(operator: address, amount: bigint): void;
-    approved(owner: address, operator: address, amount: bigint): boolean;
-    transfer(from: address, to: address, amount: bigint): void;
-}

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

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

package/exports/voting/voting.d.ts

@@ -1,38 +0,0 @@
-import ContractCreator, { ContractCreatorState } from '../contract-creator.js';
-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: VotingState);
-    get votes(): {
-        [x: string]: Vote;
-    };
-    get votingDuration(): number;
-    get votingDisabled(): boolean;
-    get state(): VotingState;
-    /**
-     * 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>;
-    get votesInProgress(): {
-        id: string;
-        title: string;
-        method: string;
-        args: any[];
-        description: string;
-        endTime: number;
-        results?: {
-            [address: string]: VoteResult;
-        };
-        finished?: boolean;
-        enoughVotes?: boolean;
-    }[];
-    disableVoting(): void;
-    sync(): void;
-}