@leofcoin/contracts 0.1.22 → 0.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/contracts",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "",
   "type": "module",
   "exports": {
@@ -28,8 +28,7 @@
   },
   "homepage": "https://github.com/leofcoin/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,16 +1,133 @@
 import Token, { TokenState } from '@leofcoin/standards/token.js'
 
+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 {
-  constructor(state: TokenState) {
-    super('Leofcoin', 'LFC', 18, state)
-    // 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')
+  #targetSupply: bigint
+  #initialSupply: bigint
+
+  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')
+    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 state(): LeofcoinState {
+    return {
+      ...super.state,
+      initialSupply: this.#initialSupply,
+      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'
 
@@ -142,34 +141,13 @@ export default class Validators extends Roles {
   }
 
   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/native-token.js

@@ -1,89 +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()
+    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, 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('should grant MINT role to owner', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    assert.equal(await token.hasRole(ownerAddress, 'MINT'), true)
+  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 be able to mint', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    await token.mint(ownerAddress, 100000n)
-    assert.equal(token.balanceOf(ownerAddress), 100000n)
+  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, targetSupply)
+    assert.equal(restored.initialSupply, initialSupply)
+    assert.equal(restored.totalSupply, initialSupply + 100n)
+    assert.equal(restored.balanceOf(ownerAddress), 600_100n)
   })
 
-  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('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 grant the genesis owner protocol burn authority', () => {
-    assert.equal(token.hasRole(ownerAddress, 'BURN'), true)
+  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 burn balance and reduce total supply', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    await token.mint(ownerAddress, 100000n)
-    await token.burn(ownerAddress, 10000n)
-    assert.equal(token.balanceOf(ownerAddress), 90000n)
-    assert.equal(token.totalSupply, 90000n)
+  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 not be able to burn more than balance', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
-    await token.mint(ownerAddress, 100000n)
+  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)
+  })
 
-    await assert.rejects(async () => await token.burn(ownerAddress, 100001n), {
-      message: 'amount exceeds balance'
-    })
+  it('allows allocated holders to transfer', () => {
+    msg.sender = receiverAddress
+    token.transfer(receiverAddress, otherReceiverAddress, 10_000n)
+    assert.equal(token.balanceOf(receiverAddress), 390_000n)
+    assert.equal(token.balanceOf(otherReceiverAddress), 10_000n)
   })
 
-  it('should not be able to mint if not MINT role', async () => {
-    assert.throws(() => token.mint(ownerAddress, 100000n), { message: 'not allowed' })
+  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 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'
+  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' })
   })
 })