@leofcoin/contracts 0.1.21 → 0.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/contracts",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "",
   "type": "module",
   "exports": {

package/src/native-token.ts

@@ -1,10 +1,25 @@
 import Token, { TokenState } from '@leofcoin/standards/token.js'
 
+interface LeofcoinState extends TokenState { targetSupply: bigint }
+
 export default class Leofcoin extends Token {
-  constructor(state: TokenState) {
+  #targetSupply: bigint
+
+  constructor(targetSupply: bigint, state: LeofcoinState) {
     super('Leofcoin', 'LFC', 18, state)
+    this.#targetSupply = state ? BigInt(state.targetSupply) : BigInt(targetSupply)
+    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')
   }
 
+  get targetSupply() { return this.#targetSupply }
+
+  get state(): LeofcoinState { return { ...super.state, targetSupply: this.#targetSupply } as LeofcoinState }
+
   burn(from: address, amount: bigint) {
     // Prevent balance underflow when burning
     if (this.balanceOf(from) < amount) throw new Error('amount exceeds balance')

package/test/native-token.js

@@ -20,7 +20,7 @@ describe('Leofcoin', () => {
       }
     }
 
-    token = new Leofcoin()
+    token = new Leofcoin(1_000_000n)
   })
 
   it('should create an instance of Leofcoin', () => {
@@ -31,21 +31,26 @@ describe('Leofcoin', () => {
     assert.equal(token.name, 'Leofcoin')
     assert.equal(token.symbol, 'LFC')
     assert.equal(token.decimals, 18)
+    assert.equal(token.targetSupply, 1_000_000n)
   })
 
-  it('should grant MINT role to owner', async () => {
-    await token.grantRole(ownerAddress, 'MINT')
+  it('should persist the immutable monetary target in state', () => {
+    token.mint(ownerAddress, 100n)
+    const restored = new Leofcoin(999n, token.state)
+    assert.equal(restored.targetSupply, 1_000_000n)
+    assert.equal(restored.totalSupply, 100n)
+  })
+
+  it('should grant protocol MINT role to owner', async () => {
     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)
@@ -53,17 +58,18 @@ describe('Leofcoin', () => {
     assert.equal(token.balanceOf(otherReceiverAddress), 10000n)
   })
 
-  it('should be able to burn', async () => {
-    await token.grantRole(ownerAddress, 'BURN')
-    await token.grantRole(ownerAddress, 'MINT')
+  it('should grant the genesis owner protocol burn authority', () => {
+    assert.equal(token.hasRole(ownerAddress, 'BURN'), true)
+  })
+
+  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('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), {
@@ -72,11 +78,11 @@ describe('Leofcoin', () => {
   })
 
   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.grantRole(ownerAddress, 'MINT')
     await token.mint(receiverAddress, 100000n)
     msg.sender = receiverAddress
     assert.throws(() => token.transfer(receiverAddress, otherReceiverAddress, 100001n), {