@leofcoin/contracts 0.1.13 → 0.1.15

package/src/name-service.ts

@@ -1,92 +1,93 @@
-import { Roles, TokenReceiver } from '@leofcoin/standards'
-import { TokenReceiverState } from '@leofcoin/standards/token-receiver'
-
-type registry = {
-  name?: {
-    address: address
-    owner: address
-  }
-}
-
-export interface NameServiceState extends TokenReceiverState {
-  registry: registry
-}
-
-export default class NameService extends TokenReceiver {
-  /**
-   * string
-   */
-  #name: string = 'LeofcoinNameService'
-  /**
-   * Object => string
-   */
-  #registry: registry = {}
-
-  get name(): string {
-    return this.#name
-  }
-
-  get registry(): {} {
-    return { ...this.#registry }
-  }
-
-  get state(): NameServiceState {
-    return {
-      ...super.state,
-      registry: this.#registry
-    }
-  }
-
-  // TODO: control with contract
-  constructor(
-    factoryAddress: address,
-    tokenToReceive: address,
-    validatorAddress: address,
-    tokenAmountToReceive: bigint,
-    state: NameServiceState
-  ) {
-    super(tokenToReceive, tokenAmountToReceive, true, state as TokenReceiverState)
-    if (state) {
-      this.#registry = state.registry
-    } else {
-      this.#registry['LeofcoinContractFactory'] = {
-        owner: msg.sender,
-        address: factoryAddress
-      }
-
-      this.#registry['LeofcoinToken'] = {
-        owner: msg.sender,
-        address: tokenToReceive
-      }
-
-      this.#registry['LeofcoinValidators'] = {
-        owner: msg.sender,
-        address: validatorAddress
-      }
-    }
-  }
-
-  async purchaseName(name: string | number, address: any) {
-    await this._canPay()
-    await this._payTokenToReceive()
-
-    this.#registry[name] = {
-      owner: msg.sender,
-      address
-    }
-  }
-
-  lookup(name: string | number) {
-    return this.#registry[name]
-  }
-
-  transferOwnership(name: string | number, to: any) {
-    if (msg.sender !== this.#registry[name].owner) throw new Error('not allowed')
-    this.#registry[name].owner = to
-  }
-
-  changeAddress(name: string | number, address: any) {
-    if (msg.sender !== this.#registry[name].owner) throw new Error('not allowed')
-    this.#registry[name].address = address
-  }
-}
+import { TokenReceiver } from '@leofcoin/standards'
+import { TokenReceiverState } from '@leofcoin/standards/token-receiver'
+
+type registry = {
+  name?: {
+    address: address
+    owner: address
+  }
+}
+
+export interface NameServiceState extends TokenReceiverState {
+  registry: registry
+}
+
+export default class NameService extends TokenReceiver {
+  /**
+   * string
+   */
+  #name: string = 'LeofcoinNameService'
+  /**
+   * Object => string
+   */
+  #registry: registry = {}
+
+  get name(): string {
+    return this.#name
+  }
+
+  get registry(): {} {
+    return { ...this.#registry }
+  }
+
+  get state(): NameServiceState {
+    const baseState = super.state as TokenReceiverState
+    return {
+      ...baseState,
+      registry: this.#registry
+    }
+  }
+
+  // TODO: control with contract
+  constructor(
+    factoryAddress: address,
+    tokenToReceive: address,
+    validatorAddress: address,
+    tokenAmountToReceive: bigint,
+    state: NameServiceState
+  ) {
+    super(tokenToReceive, tokenAmountToReceive, true, state as TokenReceiverState)
+    if (state) {
+      this.#registry = state.registry
+    } else {
+      this.#registry['LeofcoinContractFactory'] = {
+        owner: msg.sender,
+        address: msg.contract
+      }
+
+      this.#registry['LeofcoinToken'] = {
+        owner: msg.sender,
+        address: tokenToReceive
+      }
+
+      this.#registry['LeofcoinValidators'] = {
+        owner: msg.sender,
+        address: validatorAddress
+      }
+    }
+  }
+
+  async purchaseName(name: string | number, address: any) {
+    if (this.#registry[name]) throw new Error('name already registered')
+    await this._payTokenToReceive()
+
+    this.#registry[name] = {
+      owner: msg.sender,
+      address
+    }
+  }
+
+  lookup(name: string | number) {
+    return this.#registry[name]
+  }
+
+  transferOwnership(name: string | number, to: any) {
+    if (msg.sender !== this.#registry[name].owner) throw new Error('not allowed')
+    this.#registry[name].owner = to
+  }
+
+  changeAddress(name: string | number, address: any) {
+    if (msg.sender !== this.#registry[name].owner) throw new Error('not allowed')
+    this.#registry[name].address = address
+  }
+}

package/src/native-token.ts

@@ -1,7 +1,13 @@
-import Token, { TokenState } from '@leofcoin/standards/token.js'
-
-export default class Leofcoin extends Token {
-  constructor(state: TokenState) {
-    super('Leofcoin', 'LFC', 18, state)
-  }
-}
+import Token, { TokenState } from '@leofcoin/standards/token.js'
+
+export default class Leofcoin extends Token {
+  constructor(state: TokenState) {
+    super('Leofcoin', 'LFC', 18, state)
+  }
+
+  burn(from: address, amount: bigint) {
+    // Prevent balance underflow when burning
+    if (this.balanceOf(from) < amount) throw new Error('amount exceeds balance')
+    return super.burn(from, amount)
+  }
+}

package/src/power-token.ts

@@ -1,7 +1,7 @@
-import Token, { TokenState } from '@leofcoin/standards/token.js'
-
-export default class Power extends Token {
-  constructor(state: TokenState) {
-    super('Power', 'PWR', 18, state)
-  }
-}
+import Token, { TokenState } from '@leofcoin/standards/token.js'
+
+export default class Power extends Token {
+  constructor(state: TokenState) {
+    super('Power', 'PWR', 18, state)
+  }
+}

package/src/validators.ts

@@ -1,147 +1,148 @@
-import { lottery } from 'lucky-numbers'
-import Roles, { RolesState } from '@leofcoin/standards/roles.js'
-
-export declare interface ValidatorsState extends RolesState {
-  balances: { [address: string]: bigint }
-  minimumBalance: bigint
-  currency: address
-  validators: address[]
-  currentValidator: address
-}
-
-export default class Validators extends Roles {
-  /**
-   * string
-   */
-  #name = 'LeofcoinValidators'
-  /**
-   * Object => string(address) => Object
-   */
-  #validators: address[] = []
-
-  #currentValidator: address
-
-  #currency: address
-
-  #minimumBalance: bigint = BigInt(50_000)
-
-  #balances: { [address: address]: bigint } = {}
-
-  get state() {
-    return {
-      ...super.state,
-      balances: this.#balances,
-      minimumBalance: this.#minimumBalance,
-      currency: this.#currency,
-      validators: this.#validators,
-      currentValidator: this.#currentValidator
-    }
-  }
-
-  constructor(tokenAddress: address, state: ValidatorsState) {
-    super(state?.roles)
-    if (state) {
-      this.#minimumBalance = BigInt(state.minimumBalance)
-      this.#currency = state.currency
-      this.#validators = state.validators
-      this.#balances = state.balances
-      this.#currentValidator = state.currentValidator
-    } else {
-      this.#currency = tokenAddress
-      this.#validators.push(msg.sender)
-      this.#currentValidator = msg.sender
-    }
-  }
-
-  get currentValidator() {
-    return this.#currentValidator
-  }
-
-  get name() {
-    return this.#name
-  }
-
-  get currency() {
-    return this.#currency
-  }
-
-  get validators() {
-    return this.#validators
-  }
-
-  get totalValidators() {
-    return this.#validators.length
-  }
-
-  get minimumBalance() {
-    return this.#minimumBalance
-  }
-
-  changeCurrency(currency) {
-    if (!this.hasRole(msg.sender, 'OWNER')) throw new Error('not an owner')
-    this.#currency = currency
-  }
-
-  has(validator) {
-    return this.#validators.includes(validator)
-  }
-
-  #isAllowed(address) {
-    if (msg.sender !== address && !this.hasRole(msg.sender, 'OWNER'))
-      throw new Error('sender is not the validator or owner')
-    return true
-  }
-
-  async addValidator(validator: address) {
-    this.#isAllowed(validator)
-    if (this.has(validator)) throw new Error('validator already exists')
-
-    const balance = await msg.staticCall(this.currency, 'balanceOf', [validator])
-
-    if (this.minimumBalance > balance)
-      throw new Error(`balance to low! got: ${balance} need: ${this.#minimumBalance}`)
-
-    await msg.call(this.currency, 'transfer', [validator, msg.contract, this.#minimumBalance])
-
-    this.#balances[validator] = this.#minimumBalance
-    this.#validators.push(validator)
-  }
-
-  async removeValidator(validator) {
-    this.#isAllowed(validator)
-    if (!this.has(validator)) throw new Error('validator not found')
-    await msg.call(this.currency, 'transfer', [msg.contract, validator, this.#minimumBalance])
-    delete this.#balances[validator]
-    this.#validators.splice(this.#validators.indexOf(validator), 1)
-  }
-
-  shuffleValidator() {
-    // todo introduce voting mechanism
-    // select amount of peers to vote & pass when 2/3 select the same peer
-    // this.vote
-    // todo only ids should be accessable
-    const _peers = state.peers
-    const peers = _peers
-      // only validators make a chance
-      .filter((peer) => this.#validators.includes(peer[0]))
-      // add up the bytes
-      .map((peer) => {
-        peer[1].totalBytes = peer[1].bw.up + peer[1].bw.down
-        return peer
-      })
-      .sort((a, b) => b[1].totalBytes - a[1].totalBytes)
-      // only return 128 best participating max
-      .splice(0, _peers.length > 128 ? 128 : _peers.length)
-
-    const luckyNumber = lottery(1, peers.length - 1)
-
-    let nextValidator = peers[luckyNumber[0]][0]
-    // redraw when the validator is the same
-    // but keep the net alive when only one validator is found
-    if (this.#currentValidator === nextValidator && peers.length !== 1) {
-      const luckyNumber = lottery(1, peers.length - 1)
-      nextValidator = peers[luckyNumber[0]][0]
-    }
-    this.#currentValidator = nextValidator
-  }
-}
+import { lottery } from 'lucky-numbers'
+import Roles from '@leofcoin/standards/roles.js'
+import type { RolesState } from '@leofcoin/standards/interfaces.js'
+
+export declare interface ValidatorsState extends RolesState {
+  balances: { [address: string]: bigint }
+  minimumBalance: bigint
+  currency: address
+  validators: address[]
+  currentValidator: address
+}
+
+export default class Validators extends Roles {
+  /**
+   * string
+   */
+  #name = 'LeofcoinValidators'
+  /**
+   * Object => string(address) => Object
+   */
+  #validators: address[] = []
+
+  #currentValidator: address
+
+  #currency: address
+
+  #minimumBalance: bigint = BigInt(50_000)
+
+  #balances: { [address: address]: bigint } = {}
+
+  get state() {
+    return {
+      ...super.state,
+      balances: this.#balances,
+      minimumBalance: this.#minimumBalance,
+      currency: this.#currency,
+      validators: this.#validators,
+      currentValidator: this.#currentValidator
+    }
+  }
+
+  constructor(tokenAddress: address, state: ValidatorsState) {
+    super(state)
+    if (state) {
+      this.#minimumBalance = BigInt(state.minimumBalance)
+      this.#currency = state.currency
+      this.#validators = state.validators
+      this.#balances = state.balances
+      this.#currentValidator = state.currentValidator
+    } else {
+      this.#currency = tokenAddress
+      this.#validators.push(msg.sender)
+      this.#currentValidator = msg.sender
+    }
+  }
+
+  get currentValidator() {
+    return this.#currentValidator
+  }
+
+  get name() {
+    return this.#name
+  }
+
+  get currency() {
+    return this.#currency
+  }
+
+  get validators() {
+    return this.#validators
+  }
+
+  get totalValidators() {
+    return this.#validators.length
+  }
+
+  get minimumBalance() {
+    return this.#minimumBalance
+  }
+
+  changeCurrency(currency) {
+    if (!this.hasRole(msg.sender, 'OWNER')) throw new Error('not an owner')
+    this.#currency = currency
+  }
+
+  has(validator) {
+    return this.#validators.includes(validator)
+  }
+
+  #isAllowed(address) {
+    if (msg.sender !== address && !this.hasRole(msg.sender, 'OWNER'))
+      throw new Error('sender is not the validator or owner')
+    return true
+  }
+
+  async addValidator(validator: address) {
+    this.#isAllowed(validator)
+    if (this.has(validator)) throw new Error('validator already exists')
+
+    const balance = await msg.staticCall(this.currency, 'balanceOf', [validator])
+
+    if (this.minimumBalance > balance)
+      throw new Error(`balance to low! got: ${balance} need: ${this.#minimumBalance}`)
+
+    await msg.call(this.currency, 'transfer', [validator, msg.contract, this.#minimumBalance])
+
+    this.#balances[validator] = this.#minimumBalance
+    this.#validators.push(validator)
+  }
+
+  async removeValidator(validator) {
+    this.#isAllowed(validator)
+    if (!this.has(validator)) throw new Error('validator not found')
+    await msg.call(this.currency, 'transfer', [msg.contract, validator, this.#minimumBalance])
+    delete this.#balances[validator]
+    this.#validators.splice(this.#validators.indexOf(validator), 1)
+  }
+
+  shuffleValidator() {
+    // todo introduce voting mechanism
+    // select amount of peers to vote & pass when 2/3 select the same peer
+    // this.vote
+    // todo only ids should be accessable
+    const _peers = state.peers
+    const peers = _peers
+      // only validators make a chance
+      .filter((peer) => this.#validators.includes(peer[0]))
+      // add up the bytes
+      .map((peer) => {
+        peer[1].totalBytes = peer[1].bw.up + peer[1].bw.down
+        return peer
+      })
+      .sort((a, b) => b[1].totalBytes - a[1].totalBytes)
+      // only return 128 best participating max
+      .splice(0, _peers.length > 128 ? 128 : _peers.length)
+
+    const luckyNumber = lottery(1, peers.length - 1)
+
+    let nextValidator = peers[luckyNumber[0]][0]
+    // redraw when the validator is the same
+    // but keep the net alive when only one validator is found
+    if (this.#currentValidator === nextValidator && peers.length !== 1) {
+      const luckyNumber = lottery(1, peers.length - 1)
+      nextValidator = peers[luckyNumber[0]][0]
+    }
+    this.#currentValidator = nextValidator
+  }
+}

package/test/factory.js

@@ -1,66 +1,65 @@
-import Factory from './../exports/factory.js'
-import { expect } from 'chai'
-
-describe('Factory', () => {
-  let factory
-
-  beforeEach(() => {
-    global.msg = {
-      sender: '0xOwnerAddress',
-      contract: '0xContractAddress',
-      staticCall: async (currency, method, args) => {
-        console.log(currency, method, args)
-        if (method === 'balanceOf') {
-          return BigInt(100000)
-        } else if (method === '_isContractCreator') {
-          return true
-        }
-      },
-      call: async (currency, method, args) => {
-        console.log(currency, method, args)
-
-        if (method === 'balanceOf') {
-          return BigInt(100000)
-        } else if (method === '_isContractCreator') {
-          return true
-        }
-      }
-    }
-    factory = new Factory('0xTokenAddress', BigInt(1000))
-  })
-
-  it('should throw an error if balance is too low', async () => {
-    factory._canPay = () => false
-    try {
-      await factory.registerContract('0xContractAddress')
-    } catch (error) {
-      expect(error.message).to.equal("can't register, balance to low")
-    }
-  })
-
-  it('should throw an error if address is not a contract creator', async () => {
-    factory._canPay = () => true
-    factory.isCreator = async () => false
-    try {
-      await factory.registerContract('0xContractAddress')
-    } catch (error) {
-      expect(error.message).to.equal("You don't own that contract")
-    }
-  })
-
-  it('should throw an error if contract is already registered', async () => {
-    await factory.registerContract('0xContractAddress')
-    try {
-      await factory.registerContract('0xContractAddress')
-    } catch (error) {
-      expect(error.message).to.equal('already registered')
-    }
-  })
-
-  it('should successfully register a contract', async () => {
-    await factory.registerContract('0xContractAddress')
-
-    expect(factory.totalContracts).to.equal(BigInt(1))
-    expect(factory.contracts).to.include('0xContractAddress')
-  })
-})
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import Factory from './../exports/factory.js'
+
+describe('Factory', () => {
+  let factory
+
+  beforeEach(() => {
+    global.msg = {
+      sender: '0xOwnerAddress',
+      contract: '0xContractAddress',
+      staticCall: async (currency, method, args) => {
+        if (method === 'balanceOf') {
+          return BigInt(100000)
+        } else if (method === 'creator') {
+          return true
+        }
+      },
+      call: async (currency, method, args) => {
+        if (method === 'balanceOf') {
+          return BigInt(100000)
+        } else if (method === 'creator') {
+          return true
+        }
+      }
+    }
+    factory = new Factory('0xTokenAddress', BigInt(1000))
+  })
+
+  it('should throw an error if address is not a contract creator', async () => {
+    factory.isCreator = async () => false
+    await assert.rejects(async () => await factory.registerContract('0xContractAddress'), {
+      message: "You don't own that contract"
+    })
+  })
+
+  it('should throw an error if balance is too low', async () => {
+    global.msg.staticCall = async (currency, method, args) => {
+      if (method === 'balanceOf') {
+        return BigInt(100) // Balance too low
+      } else if (method === 'creator') {
+        return true
+      } else if (method === 'transfer') {
+        throw new Error('amount exceeds balance')
+      }
+    }
+    await assert.rejects(async () => await factory.registerContract('0xContractAddress'), {
+      message: 'amount exceeds balance'
+    })
+  })
+
+  it('should throw an error if contract is already registered', async () => {
+    await factory.registerContract('0xContractAddress')
+    await assert.rejects(async () => await factory.registerContract('0xContractAddress'), {
+      message: 'already registered'
+    })
+  })
+
+  it('should successfully register a contract', async () => {
+    await factory.registerContract('0xContractAddress')
+
+    assert.equal(factory.totalContracts, BigInt(1))
+    assert.ok(factory.contracts.includes('0xContractAddress'))
+  })
+})