@leofcoin/contracts 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/contracts",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "",
   "type": "module",
   "exports": {
@@ -18,18 +18,18 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/leofcoin/monorepo"
+    "url": "git+https://github.com/leofcoin/monorepo.git",
+    "directory": "packages/contracts"
   },
   "keywords": [],
   "author": "",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/leofcoin/contracts/issues"
+    "url": "https://github.com/leofcoin/monorepo/issues"
   },
-  "homepage": "https://github.com/leofcoin/contracts#readme",
+  "homepage": "https://github.com/leofcoin/monorepo/tree/main/packages/contracts#readme",
   "dependencies": {
-    "@leofcoin/standards": "^0.3.6",
-    "lucky-numbers": "^1.2.1"
+    "@leofcoin/standards": "^0.3.7"
   },
   "devDependencies": {
     "@leofcoin/types": "^1.0.26",

package/src/native-token.ts

@@ -1,27 +1,133 @@
 import Token, { TokenState } from '@leofcoin/standards/token.js'
 
-interface LeofcoinState extends TokenState { targetSupply: bigint }
+interface GenesisAllocation {
+  address: address
+  amount: bigint | string
+}
+interface LeofcoinState extends TokenState {
+  initialSupply: bigint
+  targetSupply: bigint
+}
+
+export const MONETARY_POLICY_AUTHORITY = 'leofcoin:protocol:monetary-policy:v1'
+
+const genesisState = (initialSupply: bigint, allocations: GenesisAllocation[]): TokenState => {
+  initialSupply = BigInt(initialSupply)
+  if (initialSupply <= 0n) throw new Error('initial supply must be positive')
+  if (!Array.isArray(allocations) || allocations.length === 0)
+    throw new Error('genesis allocations are required')
+
+  const balances: { [address: address]: bigint } = {}
+  let allocated = 0n
+  for (const allocation of [...allocations].sort((left, right) =>
+    left.address.localeCompare(right.address)
+  )) {
+    if (!allocation.address || balances[allocation.address] !== undefined)
+      throw new Error('invalid or duplicate genesis address')
+    const amount = BigInt(allocation.amount)
+    if (amount <= 0n) throw new Error('genesis allocation must be positive')
+    balances[allocation.address] = amount
+    allocated += amount
+  }
+  if (allocated !== initialSupply) {
+    throw new Error(
+      `genesis allocations must equal initial supply: expected ${initialSupply}, got ${allocated}`
+    )
+  }
+
+  return {
+    creator: msg.sender,
+    createdAt: BigInt(Date.now()),
+    roles: {
+      OWNER: [msg.sender],
+      MINT: [MONETARY_POLICY_AUTHORITY],
+      BURN: [MONETARY_POLICY_AUTHORITY]
+    },
+    holders: BigInt(Object.keys(balances).length),
+    balances,
+    approvals: {},
+    totalSupply: initialSupply
+  }
+}
 
 export default class Leofcoin extends Token {
   #targetSupply: bigint
+  #initialSupply: bigint
 
-  constructor(targetSupply: bigint, state: LeofcoinState) {
-    super('Leofcoin', 'LFC', 18, state)
+  constructor(
+    targetSupply: bigint,
+    initialSupplyOrState: bigint | LeofcoinState,
+    allocations: GenesisAllocation[] = [],
+    restoredState?: LeofcoinState
+  ) {
+    const legacyState =
+      initialSupplyOrState &&
+      typeof initialSupplyOrState === 'object' &&
+      !Array.isArray(initialSupplyOrState)
+        ? initialSupplyOrState
+        : undefined
+    const state = restoredState || legacyState
+    const initialSupply = state
+      ? BigInt(state.initialSupply ?? state.totalSupply)
+      : BigInt(initialSupplyOrState as bigint)
+    super('Leofcoin', 'LFC', 18, state || genesisState(initialSupply, allocations))
     this.#targetSupply = state ? BigInt(state.targetSupply) : BigInt(targetSupply)
+    this.#initialSupply = initialSupply
     if (this.#targetSupply <= 0n) throw new Error('target supply must be positive')
-    // The machine executes protocol fee burns as the immutable contract creator.
-    // Persist this capability in fresh genesis state; restored legacy state is
-    // intentionally left untouched and cannot activate fee burning.
-    if (!state && !this.hasRole(msg.sender, 'BURN')) this.grantRole(msg.sender, 'BURN')
-    if (!state && !this.hasRole(msg.sender, 'MINT')) this.grantRole(msg.sender, 'MINT')
+    if (this.#initialSupply <= 0n || this.#initialSupply > this.#targetSupply) {
+      throw new Error('initial supply must be positive and not exceed target supply')
+    }
+  }
+
+  get targetSupply() {
+    return this.#targetSupply
+  }
+  get initialSupply() {
+    return this.#initialSupply
+  }
+  get name() {
+    return 'Leofcoin'
+  }
+  get symbol() {
+    return 'LFC'
+  }
+  get decimals() {
+    return 18
   }
 
-  get targetSupply() { return this.#targetSupply }
+  get state(): LeofcoinState {
+    return {
+      ...super.state,
+      initialSupply: this.#initialSupply,
+      targetSupply: this.#targetSupply
+    } as LeofcoinState
+  }
 
-  get state(): LeofcoinState { return { ...super.state, targetSupply: this.#targetSupply } as LeofcoinState }
+  grantRole(address: address, role: string) {
+    if (role === 'MINT' || role === 'BURN') throw new Error('protocol monetary roles are immutable')
+    return super.grantRole(address, role)
+  }
+
+  revokeRole(address: address, role: string) {
+    if (role === 'MINT' || role === 'BURN') throw new Error('protocol monetary roles are immutable')
+    return super.revokeRole(address, role)
+  }
+
+  mint(to: address, amount: bigint) {
+    if (msg.sender !== MONETARY_POLICY_AUTHORITY)
+      throw new Error('only the monetary protocol may mint')
+    amount = BigInt(amount)
+    if (amount <= 0n) throw new Error('mint amount must be positive')
+    if (this.totalSupply + amount > this.#targetSupply)
+      throw new Error('mint exceeds target supply')
+    return super.mint(to, amount)
+  }
 
   burn(from: address, amount: bigint) {
-    // Prevent balance underflow when burning
+    if (msg.sender !== MONETARY_POLICY_AUTHORITY)
+      throw new Error('only the monetary protocol may burn')
+    amount = BigInt(amount)
+    if (amount <= 0n) throw new Error('burn amount must be positive')
     if (this.balanceOf(from) < amount) throw new Error('amount exceeds balance')
     return super.burn(from, amount)
   }

package/src/validators.ts

@@ -1,4 +1,3 @@
-import { lottery } from 'lucky-numbers'
 import Roles from '@leofcoin/standards/roles.js'
 import type { RolesState } from '@leofcoin/standards/interfaces.js'
 
@@ -127,7 +126,7 @@ export default class Validators extends Roles {
     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])
+    await msg.call(this.currency, 'transferFrom', [validator, msg.contract, this.#minimumBalance])
 
     this.#balances[validator] = this.#minimumBalance
     this.#validators.push(validator)
@@ -136,40 +135,19 @@ export default class Validators extends Roles {
   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])
+    await msg.call(this.currency, 'transfer', [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)
-
-    if (peers.length === 0) return
-
-    const luckyNumber = peers.length === 1 ? [0] : 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
+    const validators = [...new Set(this.#validators)].sort()
+    if (validators.length === 0) return
+    const seed = `${state.lastBlock?.hash ?? '0x0'}:${state.lastBlock?.index ?? -1}`
+    let value = 0n
+    for (const character of seed) value = (value * 31n + BigInt(character.charCodeAt(0))) % 4_294_967_291n
+    let index = Number(value % BigInt(validators.length))
+    if (validators.length > 1 && validators[index] === this.#currentValidator) index = (index + 1) % validators.length
+    this.#currentValidator = validators[index]
   }
 }

package/test/factory.js

@@ -40,10 +40,11 @@ describe('Factory', () => {
         return BigInt(100) // Balance too low
       } else if (method === 'creator') {
         return true
-      } else if (method === 'transfer') {
-        throw new Error('amount exceeds balance')
       }
     }
+    global.msg.call = async (currency, method) => {
+      if (method === 'transferFrom') throw new Error('amount exceeds balance')
+    }
     await assert.rejects(async () => await factory.registerContract('0xContractAddress'), {
       message: 'amount exceeds balance'
     })

package/test/native-token.js

@@ -1,92 +1,130 @@
 import { describe, it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
-import Leofcoin from './../exports/native-token.js'
+import Leofcoin, { MONETARY_POLICY_AUTHORITY } from './../exports/native-token.js'
 
 describe('Leofcoin', () => {
   let token
   const receiverAddress = '0xReceiverAddress'
   const otherReceiverAddress = '0xOtherReceiverAddress'
   const ownerAddress = '0xOwnerAddress'
+  const targetSupply = 10_000_000n
+  const initialSupply = 1_000_000n
+  const allocations = [
+    { address: receiverAddress, amount: 400_000n },
+    { address: ownerAddress, amount: 600_000n }
+  ]
 
   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
-      }
+      staticCall: async () => {},
+      call: async () => {}
     }
 
-    token = new Leofcoin(1_000_000n)
+    token = new Leofcoin(targetSupply, initialSupply, allocations)
   })
 
-  it('should create an instance of Leofcoin', () => {
+  it('creates the complete initial supply directly from deterministic allocations', () => {
     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)
-    assert.equal(token.targetSupply, 1_000_000n)
+    assert.equal(token.targetSupply, targetSupply)
+    assert.equal(token.initialSupply, initialSupply)
+    assert.equal(token.totalSupply, initialSupply)
+    assert.equal(token.balanceOf(ownerAddress), 600_000n)
+    assert.equal(token.balanceOf(receiverAddress), 400_000n)
+    assert.equal(token.holders, 2n)
+  })
+
+  it('sorts allocations so equivalent genesis inputs produce identical state', () => {
+    const reversed = new Leofcoin(targetSupply, initialSupply, [...allocations].reverse())
+    assert.deepEqual(reversed.balances, token.balances)
   })
 
-  it('should persist the immutable monetary target in state', () => {
+  it('persists the immutable supplies when restoring state', () => {
+    msg.sender = MONETARY_POLICY_AUTHORITY
     token.mint(ownerAddress, 100n)
     const restored = new Leofcoin(999n, token.state)
-    assert.equal(restored.targetSupply, 1_000_000n)
-    assert.equal(restored.totalSupply, 100n)
+    assert.equal(restored.targetSupply, targetSupply)
+    assert.equal(restored.initialSupply, initialSupply)
+    assert.equal(restored.totalSupply, initialSupply + 100n)
+    assert.equal(restored.balanceOf(ownerAddress), 600_100n)
   })
 
-  it('should grant protocol MINT role to owner', async () => {
-    assert.equal(await token.hasRole(ownerAddress, 'MINT'), true)
+  it('reserves mint and burn authority for the monetary protocol', () => {
+    assert.equal(token.hasRole(ownerAddress, 'OWNER'), true)
+    assert.equal(token.hasRole(ownerAddress, 'MINT'), false)
+    assert.equal(token.hasRole(ownerAddress, 'BURN'), false)
+    assert.equal(token.hasRole(MONETARY_POLICY_AUTHORITY, 'MINT'), true)
+    assert.equal(token.hasRole(MONETARY_POLICY_AUTHORITY, 'BURN'), true)
   })
 
-  it('should be able to mint', async () => {
-    await token.mint(ownerAddress, 100000n)
-    assert.equal(token.balanceOf(ownerAddress), 100000n)
+  it('prevents the owner from minting or burning', () => {
+    assert.throws(() => token.mint(ownerAddress, 1n), {
+      message: 'only the monetary protocol may mint'
+    })
+    assert.throws(() => token.burn(ownerAddress, 1n), {
+      message: 'only the monetary protocol may burn'
+    })
   })
 
-  it('should be able to transfer', async () => {
-    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('makes protocol monetary roles immutable', () => {
+    assert.throws(() => token.grantRole(ownerAddress, 'MINT'), {
+      message: 'protocol monetary roles are immutable'
+    })
+    assert.throws(() => token.revokeRole(MONETARY_POLICY_AUTHORITY, 'BURN'), {
+      message: 'protocol monetary roles are immutable'
+    })
   })
 
-  it('should grant the genesis owner protocol burn authority', () => {
-    assert.equal(token.hasRole(ownerAddress, 'BURN'), true)
+  it('allows protocol-controlled minting and burning', () => {
+    msg.sender = MONETARY_POLICY_AUTHORITY
+    token.mint(ownerAddress, 100_000n)
+    token.burn(ownerAddress, 10_000n)
+    assert.equal(token.balanceOf(ownerAddress), 690_000n)
+    assert.equal(token.totalSupply, 1_090_000n)
   })
 
-  it('should burn balance and reduce total supply', async () => {
-    await token.mint(ownerAddress, 100000n)
-    await token.burn(ownerAddress, 10000n)
-    assert.equal(token.balanceOf(ownerAddress), 90000n)
-    assert.equal(token.totalSupply, 90000n)
+  it('allows allocated holders to transfer', () => {
+    msg.sender = receiverAddress
+    token.transfer(otherReceiverAddress, 10_000n)
+    assert.equal(token.balanceOf(receiverAddress), 390_000n)
+    assert.equal(token.balanceOf(otherReceiverAddress), 10_000n)
   })
 
-  it('should not be able to burn more than balance', async () => {
-    await token.mint(ownerAddress, 100000n)
-
-    await assert.rejects(async () => await token.burn(ownerAddress, 100001n), {
-      message: 'amount exceeds balance'
+  it('rejects invalid genesis allocation sets', () => {
+    assert.throws(() => new Leofcoin(targetSupply, initialSupply, []), {
+      message: 'genesis allocations are required'
+    })
+    assert.throws(
+      () =>
+        new Leofcoin(targetSupply, initialSupply, [
+          { address: ownerAddress, amount: initialSupply - 1n }
+        ]),
+      { message: /genesis allocations must equal initial supply/ }
+    )
+    assert.throws(
+      () =>
+        new Leofcoin(targetSupply, initialSupply, [
+          { address: ownerAddress, amount: 500_000n },
+          { address: ownerAddress, amount: 500_000n }
+        ]),
+      { message: 'invalid or duplicate genesis address' }
+    )
+    assert.throws(() => new Leofcoin(1n, 2n, [{ address: ownerAddress, amount: 2n }]), {
+      message: 'initial supply must be positive and not exceed target supply'
     })
   })
 
-  it('should not be able to mint if not MINT role', async () => {
-    msg.sender = receiverAddress
-    assert.throws(() => token.mint(ownerAddress, 100000n), { message: 'not allowed' })
-  })
-
-  it('should not be able to transfer more than balance', async () => {
-    await token.mint(receiverAddress, 100000n)
-    msg.sender = receiverAddress
-    assert.throws(() => token.transfer(receiverAddress, otherReceiverAddress, 100001n), {
-      message: 'amount exceeds balance'
+  it('rejects invalid monetary amounts', () => {
+    msg.sender = MONETARY_POLICY_AUTHORITY
+    assert.throws(() => token.mint(ownerAddress, 0n), { message: 'mint amount must be positive' })
+    assert.throws(() => token.mint(ownerAddress, targetSupply), {
+      message: 'mint exceeds target supply'
     })
+    assert.throws(() => token.burn(ownerAddress, 0n), { message: 'burn amount must be positive' })
+    assert.throws(() => token.burn(ownerAddress, 600_001n), { message: 'amount exceeds balance' })
   })
 })