@leofcoin/contracts 0.1.14 → 0.1.15

package/test/native-token.js

@@ -1,96 +1,86 @@
-import { expect, use } from 'chai'
-import chaiAsPromised from 'chai-as-promised'
-import Leofcoin from './../exports/native-token.js'
-import Token from '@leofcoin/standards/token.js'
-
-use(chaiAsPromised)
-
-describe('Leofcoin', () => {
-  let state
-  let token
-  const receiverAddress = '0xReceiverAddress'
-  const otherReceiverAddress = '0xOtherReceiverAddress'
-  const ownerAddress = '0xOwnerAddress'
-
-  beforeEach(() => {
-    global.msg = {
-      sender: ownerAddress,
-      contract: '0xContractAddress',
-      staticCall: async (currency, method, args) => {
-        // Mock implementation of msg.staticCall
-      },
-      call: async (currency, method, args) => {
-        // Mock implementation of msg.call
-      }
-    }
-
-    token = new Leofcoin()
-  })
-
-  it('should create an instance of Leofcoin', () => {
-    expect(token).to.be.instanceOf(Leofcoin)
-  })
-
-  it('should have correct properties', () => {
-    expect(token.name).to.equal('Leofcoin')
-    expect(token.symbol).to.equal('LFC')
-    expect(token.decimals).to.equal(18)
-  })
-
-  it('should grant MINT role to owner', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    expect(await token.hasRole(ownerAddress, 'MINT')).to.equal(true)
-  })
-
-  it('should be able to mint', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    await token.mint(ownerAddress, 100000n)
-    expect(token.balanceOf(ownerAddress)).to.equal(100000n)
-  })
-
-  it('should be able to transfer', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    await token.mint(receiverAddress, 100000n)
-    msg.sender = receiverAddress
-    await token.transfer(receiverAddress, otherReceiverAddress, 10000n)
-    expect(token.balanceOf(receiverAddress)).to.equal(90000n)
-    expect(token.balanceOf(otherReceiverAddress)).to.equal(10000n)
-  })
-
-  it('should be able to burn', async () => {
-    await token.grantRole(ownerAddress, 'BURN')
-    await token.grantRole(ownerAddress, 'MINT')
-    await token.mint(ownerAddress, 100000n)
-    await token.burn(ownerAddress, 10000n)
-    expect(token.balanceOf(ownerAddress)).to.equal(90000n)
-  })
-
-  it('should not be able to burn more than balance', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    await token.mint(ownerAddress, 100000n)
-
-    try {
-      await token.burn(ownerAddress, 100001n)
-    } catch (error) {
-      expect(error.message).to.equal('amount exceeds balance')
-    }
-  })
-
-  it('should not be able to mint if not MINT role', async () => {
-    try {
-      await token.mint(ownerAddress, 100000n)
-    } catch (error) {
-      expect(error.message).to.equal('mint role required')
-    }
-  })
-
-  it('should not be able to transfer more than balance', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    await token.mint(receiverAddress, 100000n)
-    try {
-      await token.transfer(receiverAddress, otherReceiverAddress, 100001n)
-    } catch (error) {
-      expect(error.message).to.equal('amount exceeds balance')
-    }
-  })
-})
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import Leofcoin from './../exports/native-token.js'
+
+describe('Leofcoin', () => {
+  let token
+  const receiverAddress = '0xReceiverAddress'
+  const otherReceiverAddress = '0xOtherReceiverAddress'
+  const ownerAddress = '0xOwnerAddress'
+
+  beforeEach(() => {
+    global.msg = {
+      sender: ownerAddress,
+      contract: '0xContractAddress',
+      staticCall: async (currency, method, args) => {
+        // Mock implementation of msg.staticCall
+      },
+      call: async (currency, method, args) => {
+        // Mock implementation of msg.call
+      }
+    }
+
+    token = new Leofcoin()
+  })
+
+  it('should create an instance of Leofcoin', () => {
+    assert.ok(token instanceof Leofcoin)
+  })
+
+  it('should have correct properties', () => {
+    assert.equal(token.name, 'Leofcoin')
+    assert.equal(token.symbol, 'LFC')
+    assert.equal(token.decimals, 18)
+  })
+
+  it('should grant MINT role to owner', async () => {
+    await token.grantRole(ownerAddress, 'MINT')
+    assert.equal(await token.hasRole(ownerAddress, 'MINT'), true)
+  })
+
+  it('should be able to mint', async () => {
+    await token.grantRole(ownerAddress, 'MINT')
+    await token.mint(ownerAddress, 100000n)
+    assert.equal(token.balanceOf(ownerAddress), 100000n)
+  })
+
+  it('should be able to transfer', async () => {
+    await token.grantRole(ownerAddress, 'MINT')
+    await token.mint(receiverAddress, 100000n)
+    msg.sender = receiverAddress
+    await token.transfer(receiverAddress, otherReceiverAddress, 10000n)
+    assert.equal(token.balanceOf(receiverAddress), 90000n)
+    assert.equal(token.balanceOf(otherReceiverAddress), 10000n)
+  })
+
+  it('should be able to burn', async () => {
+    await token.grantRole(ownerAddress, 'BURN')
+    await token.grantRole(ownerAddress, 'MINT')
+    await token.mint(ownerAddress, 100000n)
+    await token.burn(ownerAddress, 10000n)
+    assert.equal(token.balanceOf(ownerAddress), 90000n)
+  })
+
+  it('should not be able to burn more than balance', async () => {
+    await token.grantRole(ownerAddress, 'MINT')
+    await token.grantRole(ownerAddress, 'BURN')
+    await token.mint(ownerAddress, 100000n)
+
+    await assert.rejects(async () => await token.burn(ownerAddress, 100001n), {
+      message: 'amount exceeds balance'
+    })
+  })
+
+  it('should not be able to mint if not MINT role', async () => {
+    assert.throws(() => token.mint(ownerAddress, 100000n), { message: 'not allowed' })
+  })
+
+  it('should not be able to transfer more than balance', async () => {
+    await token.grantRole(ownerAddress, 'MINT')
+    await token.mint(receiverAddress, 100000n)
+    msg.sender = receiverAddress
+    assert.throws(() => token.transfer(receiverAddress, otherReceiverAddress, 100001n), {
+      message: 'amount exceeds balance'
+    })
+  })
+})

package/test/validators.js

@@ -1,120 +1,119 @@
-import { expect, use } from 'chai'
-import chaiAsPromised from 'chai-as-promised'
-import { describe, it, beforeEach } from 'mocha'
-import Validators from '../exports/validators.js'
-
-use(chaiAsPromised)
-
-describe('Validators', () => {
-  let validators
-  let validatorState
-  const tokenAddress = '0xTokenAddress'
-  const ownerAddress = '0xOwnerAddress'
-  const validatorAddress = '0xValidatorAddress'
-  const anotherValidatorAddress = '0xAnotherValidatorAddress'
-
-  beforeEach(() => {
-    global.state = {
-      peers: [
-        [ownerAddress, { bw: { up: 100, down: 100 } }],
-        [validatorAddress, { bw: { up: 100, down: 100 } }],
-        [anotherValidatorAddress, { bw: { up: 200, down: 200 } }]
-      ]
-    }
-    global.msg = {
-      sender: ownerAddress,
-      contract: '0xContractAddress',
-      staticCall: async (currency, method, args) => {
-        if (method === 'balanceOf') {
-          if (args[0] === validatorAddress) return BigInt(100000)
-          if (args[0] === anotherValidatorAddress) return BigInt(100000)
-        }
-        return BigInt(0)
-      },
-      call: async (currency, method, args) => {
-        // Mock implementation of msg.call
-      }
-    }
-    validators = new Validators(tokenAddress, validatorState)
-  })
-
-  it('should initialize with default values', () => {
-    expect(validators.name).to.equal('LeofcoinValidators')
-    expect(validators.currency).to.equal(tokenAddress)
-    expect(validators.validators).to.deep.equal([ownerAddress])
-    expect(validators.totalValidators).to.equal(1)
-    expect(validators.minimumBalance.toString()).to.equal(BigInt(50000).toString())
-  })
-
-  it('should change currency if sender is owner', () => {
-    validators.changeCurrency('0xNewCurrencyAddress')
-    expect(validators.currency).to.equal('0xNewCurrencyAddress')
-  })
-
-  it('should throw error if non-owner tries to change currency', () => {
-    global.msg.sender = validatorAddress
-    expect(() => validators.changeCurrency('0xNewCurrencyAddress')).to.throw('not an owner')
-  })
-
-  it('should add a validator if conditions are met', async () => {
-    await validators.addValidator(validatorAddress)
-    expect(validators.validators).to.include(validatorAddress)
-    expect(validators.totalValidators).to.equal(2)
-  })
-
-  it('should throw error if adding an existing validator', async () => {
-    await validators.addValidator(validatorAddress)
-    await expect(validators.addValidator(validatorAddress)).to.be.rejectedWith(
-      'validator already exists'
-    )
-  })
-
-  it('should throw error if validator balance is too low', async () => {
-    global.msg.staticCall = async (currency, method, args) => BigInt(1000)
-    await expect(validators.addValidator(anotherValidatorAddress)).to.be.rejectedWith(
-      'balance to low! got: 1000 need: 50000'
-    )
-  })
-
-  it('should remove a validator if conditions are met', async () => {
-    await validators.addValidator(validatorAddress)
-    await validators.removeValidator(validatorAddress)
-    expect(validators.validators).to.not.include(validatorAddress)
-    expect(validators.totalValidators).to.equal(1)
-  })
-
-  it('should throw error if removing a non-existing validator', async () => {
-    await expect(validators.removeValidator(validatorAddress)).to.be.rejectedWith(
-      'validator not found'
-    )
-  })
-
-  it('should shuffle validator correctly', async () => {
-    validators.shuffleValidator()
-    expect(validators.currentValidator).to.include(ownerAddress)
-    await validators.removeValidator(ownerAddress)
-
-    global.msg.sender = validatorAddress
-    await validators.addValidator(validatorAddress)
-
-    validators.shuffleValidator()
-    expect(validators.currentValidator).to.include(validatorAddress)
-  })
-
-  it('should return the current validator', () => {
-    expect(validators.currentValidator).to.equal(ownerAddress)
-  })
-
-  it('should return state correctly', async () => {
-    msg.sender = validatorAddress
-    await validators.addValidator(validatorAddress)
-    validatorState = validators.state
-    expect(validatorState.validators).to.deep.equal([ownerAddress, validatorAddress])
-  })
-
-  it('should restore from state correctly', () => {
-    const newValidators = new Validators(tokenAddress, validatorState)
-    expect(newValidators.validators).to.deep.equal([ownerAddress, validatorAddress])
-    expect(newValidators.totalValidators).to.equal(2)
-  })
-})
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import Validators from '../exports/validators.js'
+
+describe('Validators', () => {
+  let validators
+  let validatorState
+  const tokenAddress = '0xTokenAddress'
+  const ownerAddress = '0xOwnerAddress'
+  const validatorAddress = '0xValidatorAddress'
+  const anotherValidatorAddress = '0xAnotherValidatorAddress'
+
+  beforeEach(() => {
+    global.state = {
+      peers: [
+        [ownerAddress, { bw: { up: 100, down: 100 } }],
+        [validatorAddress, { bw: { up: 100, down: 100 } }],
+        [anotherValidatorAddress, { bw: { up: 200, down: 200 } }]
+      ]
+    }
+    global.msg = {
+      sender: ownerAddress,
+      contract: '0xContractAddress',
+      staticCall: async (currency, method, args) => {
+        if (method === 'balanceOf') {
+          if (args[0] === validatorAddress) return BigInt(100000)
+          if (args[0] === anotherValidatorAddress) return BigInt(100000)
+        }
+        return BigInt(0)
+      },
+      call: async (currency, method, args) => {
+        // Mock implementation of msg.call
+      }
+    }
+    validators = new Validators(tokenAddress, validatorState)
+  })
+
+  it('should initialize with default values', () => {
+    assert.equal(validators.name, 'LeofcoinValidators')
+    assert.equal(validators.currency, tokenAddress)
+    assert.deepEqual(validators.validators, [ownerAddress])
+    assert.equal(validators.totalValidators, 1)
+    assert.equal(validators.minimumBalance.toString(), BigInt(50000).toString())
+  })
+
+  it('should change currency if sender is owner', () => {
+    validators.changeCurrency('0xNewCurrencyAddress')
+    assert.equal(validators.currency, '0xNewCurrencyAddress')
+  })
+
+  it('should throw error if non-owner tries to change currency', () => {
+    global.msg.sender = validatorAddress
+    assert.throws(() => validators.changeCurrency('0xNewCurrencyAddress'), {
+      message: 'not an owner'
+    })
+  })
+
+  it('should add a validator if conditions are met', async () => {
+    await validators.addValidator(validatorAddress)
+    assert.ok(validators.validators.includes(validatorAddress))
+    assert.equal(validators.totalValidators, 2)
+  })
+
+  it('should throw error if adding an existing validator', async () => {
+    await validators.addValidator(validatorAddress)
+    await assert.rejects(async () => await validators.addValidator(validatorAddress), {
+      message: 'validator already exists'
+    })
+  })
+
+  it('should throw error if validator balance is too low', async () => {
+    global.msg.staticCall = async (currency, method, args) => BigInt(1000)
+    await assert.rejects(async () => await validators.addValidator(anotherValidatorAddress), {
+      message: 'balance to low! got: 1000 need: 50000'
+    })
+  })
+
+  it('should remove a validator if conditions are met', async () => {
+    await validators.addValidator(validatorAddress)
+    await validators.removeValidator(validatorAddress)
+    assert.ok(!validators.validators.includes(validatorAddress))
+    assert.equal(validators.totalValidators, 1)
+  })
+
+  it('should throw error if removing a non-existing validator', async () => {
+    await assert.rejects(async () => await validators.removeValidator(validatorAddress), {
+      message: 'validator not found'
+    })
+  })
+
+  it('should shuffle validator correctly', async () => {
+    validators.shuffleValidator()
+    assert.ok(validators.currentValidator.includes(ownerAddress))
+    await validators.removeValidator(ownerAddress)
+
+    global.msg.sender = validatorAddress
+    await validators.addValidator(validatorAddress)
+
+    validators.shuffleValidator()
+    assert.ok(validators.currentValidator.includes(validatorAddress))
+  })
+
+  it('should return the current validator', () => {
+    assert.equal(validators.currentValidator, ownerAddress)
+  })
+
+  it('should return state correctly', async () => {
+    msg.sender = validatorAddress
+    await validators.addValidator(validatorAddress)
+    validatorState = validators.state
+    assert.deepEqual(validatorState.validators, [ownerAddress, validatorAddress])
+  })
+
+  it('should restore from state correctly', () => {
+    const newValidators = new Validators(tokenAddress, validatorState)
+    assert.deepEqual(newValidators.validators, [ownerAddress, validatorAddress])
+    assert.equal(newValidators.totalValidators, 2)
+  })
+})

package/tsconfig.json

@@ -1,13 +1,14 @@
-{
-  "compilerOptions": {
-    "module": "NodeNext",
-    "declarationDir": "./exports",
-    "moduleResolution": "NodeNext",
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "types": ["@leofcoin/types", "@leofcoin/types/global"]
-  },
-  "include": ["./src/**/*"]
-}
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "declarationDir": "./exports",
+    "moduleResolution": "NodeNext",
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "outDir": "exports",
+    "types": ["@leofcoin/types", "@leofcoin/types/global"]
+  },
+  "include": ["./src/**/*"]
+}