@leofcoin/chain 1.9.16 → 1.9.18

package/exports/chain.js

@@ -1,64 +1,89 @@
-import { createDebugger } from '@vandeurenglenn/debug';
-import { jsonStringifyBigInt, jsonParseBigInt, formatBytes, parseUnits, formatUnits } from '@leofcoin/utils';
-import { TransactionMessage, BlockMessage, ContractMessage, LastBlockMessage, PrevoteMessage, PrecommitMessage, ProposalMessage, BWMessage, StateMessage, BWRequestMessage } from '@leofcoin/messages';
-import addresses, { contractFactory } from '@leofcoin/addresses';
-import { calculateFee, createContractMessage, signTransaction, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
-import semver from 'semver';
-import { randombytes } from '@leofcoin/crypto';
-import EasyWorker from '@vandeurenglenn/easy-worker';
-import { ContractDeploymentError, ExecutionError, isResolveError, ResolveError, isExecutionError } from '@leofcoin/errors';
-import { P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO } from './constants-C83ZCYKa.js';
-import '@leofcoin/networks';
+import { createDebugger } from '@vandeurenglenn/debug'
+import { jsonStringifyBigInt, jsonParseBigInt, formatBytes, parseUnits, formatUnits } from '@leofcoin/utils'
+import {
+  TransactionMessage,
+  BlockMessage,
+  ContractMessage,
+  LastBlockMessage,
+  PrevoteMessage,
+  PrecommitMessage,
+  ProposalMessage,
+  BWMessage,
+  StateMessage,
+  BWRequestMessage
+} from '@leofcoin/messages'
+import addresses, { contractFactory } from '@leofcoin/addresses'
+import {
+  calculateFee,
+  createContractMessage,
+  signTransaction,
+  contractFactoryMessage,
+  nativeTokenMessage,
+  validatorsMessage,
+  nameServiceMessage
+} from '@leofcoin/lib'
+import semver from 'semver'
+import { randombytes } from '@leofcoin/crypto'
+import EasyWorker from '@vandeurenglenn/easy-worker'
+import {
+  ContractDeploymentError,
+  ExecutionError,
+  isResolveError,
+  ResolveError,
+  isExecutionError
+} from '@leofcoin/errors'
+import { P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO } from './constants-C83ZCYKa.js'
+import '@leofcoin/networks'
 
-const limit = 1800;
-const transactionLimit = 2500;
-const requestTimeout = 3e4;
-const syncTimeout = 3e4;
+const limit = 1800
+const transactionLimit = 2500
+const requestTimeout = 3e4
+const syncTimeout = 3e4
 class Protocol {
   constructor(config) {
-    this.resolveTimeout = 1e4;
-    if (config?.resolveTimeout) this.resolveTimeout = config.resolveTimeout;
+    this.resolveTimeout = 1e4
+    if (config?.resolveTimeout) this.resolveTimeout = config.resolveTimeout
   }
   get limit() {
-    return limit;
+    return limit
   }
   get transactionLimit() {
-    return transactionLimit;
+    return transactionLimit
   }
   get requestTimeout() {
-    return requestTimeout;
+    return requestTimeout
   }
   get syncTimeout() {
-    return syncTimeout;
+    return syncTimeout
   }
 }
 
 class Transaction extends Protocol {
-  #pendingNonces = /* @__PURE__ */ new Map();
-  #maxPendingNonce = /* @__PURE__ */ new Map();
+  #pendingNonces = /* @__PURE__ */ new Map()
+  #maxPendingNonce = /* @__PURE__ */ new Map()
   constructor(config) {
-    super(config);
+    super(config)
   }
   addPendingNonce(address, nonce) {
     if (!this.#pendingNonces.has(address)) {
-      this.#pendingNonces.set(address, /* @__PURE__ */ new Set());
+      this.#pendingNonces.set(address, /* @__PURE__ */ new Set())
     }
-    this.#pendingNonces.get(address).add(nonce);
-    const currentMax = this.#maxPendingNonce.get(address) ?? -1;
+    this.#pendingNonces.get(address).add(nonce)
+    const currentMax = this.#maxPendingNonce.get(address) ?? -1
     if (nonce > currentMax) {
-      this.#maxPendingNonce.set(address, nonce);
+      this.#maxPendingNonce.set(address, nonce)
     }
   }
   removePendingNonce(address, nonce) {
     if (this.#pendingNonces.has(address)) {
-      this.#pendingNonces.get(address).delete(nonce);
+      this.#pendingNonces.get(address).delete(nonce)
     }
   }
   getPendingNonces(address) {
-    return this.#pendingNonces.get(address) || /* @__PURE__ */ new Set();
+    return this.#pendingNonces.get(address) || /* @__PURE__ */ new Set()
   }
   getMaxPendingNonce(address) {
-    return this.#maxPendingNonce.get(address) ?? -1;
+    return this.#maxPendingNonce.get(address) ?? -1
   }
   /**
    *
@@ -67,23 +92,23 @@ class Transaction extends Protocol {
    */
   async getTransactions(transactions) {
     return new Promise(async (resolve, reject) => {
-      let size = 0;
-      const _transactions = [];
-      const MAX_BLOCK_TX_BYTES = 786432;
+      let size = 0
+      const _transactions = []
+      const MAX_BLOCK_TX_BYTES = 786432
       await Promise.all(
         transactions.map(async (tx) => {
-          tx = await new TransactionMessage(tx);
-          const newSize = size + tx.encoded.length;
+          tx = await new TransactionMessage(tx)
+          const newSize = size + tx.encoded.length
           if (newSize <= MAX_BLOCK_TX_BYTES) {
-            size = newSize;
-            _transactions.push({ ...tx.decoded, hash: await tx.hash() });
+            size = newSize
+            _transactions.push({ ...tx.decoded, hash: await tx.hash() })
           } else {
-            resolve(_transactions);
+            resolve(_transactions)
           }
         })
-      );
-      return resolve(_transactions);
-    });
+      )
+      return resolve(_transactions)
+    })
   }
   /**
    *
@@ -91,8 +116,8 @@ class Transaction extends Protocol {
    * @returns {TransactionMessage}
    */
   async promiseTransactions(transactions) {
-    transactions = await Promise.all(transactions.map((tx) => new TransactionMessage(tx.encoded || tx)));
-    return transactions;
+    transactions = await Promise.all(transactions.map((tx) => new TransactionMessage(tx.encoded || tx)))
+    return transactions
   }
   /**
    *
@@ -102,12 +127,13 @@ class Transaction extends Protocol {
   async promiseTransactionsContent(transactions) {
     transactions = await Promise.all(
       transactions.map(
-        (tx) => new Promise(async (resolve, reject) => {
-          resolve({ ...tx.decoded, hash: await tx.hash() });
-        })
+        (tx) =>
+          new Promise(async (resolve, reject) => {
+            resolve({ ...tx.decoded, hash: await tx.hash() })
+          })
       )
-    );
-    return transactions;
+    )
+    return transactions
   }
   /**
    * When a nonce isn't found for an address fallback to just checking the transactionnPoolStore
@@ -115,32 +141,32 @@ class Transaction extends Protocol {
    * @returns {Number} nonce
    */
   async #getNonceFallback(address) {
-    let transactions = await globalThis.transactionPoolStore.values();
-    transactions = await this.promiseTransactions(transactions);
-    transactions = transactions.filter((tx) => tx.decoded.from === address);
-    transactions = await this.promiseTransactionsContent(transactions);
-    if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== "0x0") {
-      let block;
+    let transactions = await globalThis.transactionPoolStore.values()
+    transactions = await this.promiseTransactions(transactions)
+    transactions = transactions.filter((tx) => tx.decoded.from === address)
+    transactions = await this.promiseTransactionsContent(transactions)
+    if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== '0x0') {
+      let block
       try {
-        block = await globalThis.peernet.get(this.lastBlock.hash, "block");
+        block = await globalThis.peernet.get(this.lastBlock.hash, 'block')
       } catch (error) {
-        block = void 0;
+        block = void 0
       }
-      if (block === void 0) return [];
-      block = await new BlockMessage(block);
-      transactions = transactions.filter((tx) => tx.from === address);
-      while (transactions.length === 0 && block.decoded.index !== 0 && block.decoded.previousHash !== "0x0") {
-        block = await globalThis.blockStore.get(block.decoded.previousHash);
-        block = await new BlockMessage(block);
-        transactions = block.decoded.transactions.filter((tx) => tx.from === address);
+      if (block === void 0) return []
+      block = await new BlockMessage(block)
+      transactions = transactions.filter((tx) => tx.from === address)
+      while (transactions.length === 0 && block.decoded.index !== 0 && block.decoded.previousHash !== '0x0') {
+        block = await globalThis.blockStore.get(block.decoded.previousHash)
+        block = await new BlockMessage(block)
+        transactions = block.decoded.transactions.filter((tx) => tx.from === address)
       }
     }
-    if (transactions.length === 0) return 0;
-    let maxNonce = 0;
+    if (transactions.length === 0) return 0
+    let maxNonce = 0
     for (const tx of transactions) {
-      if (tx.nonce > maxNonce) maxNonce = tx.nonce;
+      if (tx.nonce > maxNonce) maxNonce = tx.nonce
     }
-    return maxNonce;
+    return maxNonce
   }
   /**
    * Get amount of transactions by address
@@ -149,126 +175,126 @@ class Transaction extends Protocol {
    */
   async getNonce(address) {
     try {
-      if (!await globalThis.accountsStore.has(address)) {
-        const nonce2 = await this.#getNonceFallback(address);
-        await globalThis.accountsStore.put(address, new TextEncoder().encode(String(nonce2)));
+      if (!(await globalThis.accountsStore.has(address))) {
+        const nonce2 = await this.#getNonceFallback(address)
+        await globalThis.accountsStore.put(address, new TextEncoder().encode(String(nonce2)))
       }
     } catch (error) {
-      const nonce2 = await this.#getNonceFallback(address);
-      await globalThis.accountsStore.put(address, new TextEncoder().encode(String(nonce2)));
+      const nonce2 = await this.#getNonceFallback(address)
+      await globalThis.accountsStore.put(address, new TextEncoder().encode(String(nonce2)))
     }
-    let nonce = await globalThis.accountsStore.get(address);
-    nonce = Number(new TextDecoder().decode(nonce));
-    const maxPending = this.getMaxPendingNonce(address);
+    let nonce = await globalThis.accountsStore.get(address)
+    nonce = Number(new TextDecoder().decode(nonce))
+    const maxPending = this.getMaxPendingNonce(address)
     if (maxPending > nonce) {
-      return maxPending;
+      return maxPending
     }
-    return nonce;
+    return nonce
   }
   async validateNonce(address, nonce) {
-    let committedNonce;
+    let committedNonce
     try {
       if (await globalThis.accountsStore.has(address)) {
-        const raw = await globalThis.accountsStore.get(address);
-        committedNonce = Number(new TextDecoder().decode(raw));
+        const raw = await globalThis.accountsStore.get(address)
+        committedNonce = Number(new TextDecoder().decode(raw))
       } else {
-        committedNonce = await this.#getNonceFallback(address);
+        committedNonce = await this.#getNonceFallback(address)
       }
     } catch {
-      committedNonce = 0;
+      committedNonce = 0
     }
-    if (committedNonce >= nonce) throw new Error(`a transaction with the same nonce already exists`);
-    const pendingNonces = this.getPendingNonces(address);
-    if (pendingNonces.has(nonce)) throw new Error(`a transaction with the same nonce already exists`);
+    if (committedNonce >= nonce) throw new Error(`a transaction with the same nonce already exists`)
+    const pendingNonces = this.getPendingNonces(address)
+    if (pendingNonces.has(nonce)) throw new Error(`a transaction with the same nonce already exists`)
   }
   isTransactionMessage(message) {
-    if (message instanceof TransactionMessage) return true;
-    return false;
+    if (message instanceof TransactionMessage) return true
+    return false
   }
   async createTransactionMessage(transaction, signature) {
-    return new TransactionMessage({ ...transaction, signature });
+    return new TransactionMessage({ ...transaction, signature })
   }
   async createTransaction(transaction) {
     return {
       ...transaction,
       timestamp: transaction.timestamp || Date.now(),
-      nonce: transaction.nonce || await this.getNonce(transaction.from) + 1
-    };
+      nonce: transaction.nonce || (await this.getNonce(transaction.from)) + 1
+    }
   }
   async sendTransaction(message) {
-    if (!this.isTransactionMessage(message)) message = await new TransactionMessage(message);
-    if (!message.decoded.signature) throw new Error(`transaction not signed`);
-    if (message.decoded.nonce === void 0) throw new Error(`nonce required`);
-    await this.validateNonce(message.decoded.from, message.decoded.nonce);
-    const hash = await message.hash();
+    if (!this.isTransactionMessage(message)) message = await new TransactionMessage(message)
+    if (!message.decoded.signature) throw new Error(`transaction not signed`)
+    if (message.decoded.nonce === void 0) throw new Error(`nonce required`)
+    await this.validateNonce(message.decoded.from, message.decoded.nonce)
+    const hash = await message.hash()
     try {
-      let data;
+      let data
       const wait = new Promise(async (resolve, reject) => {
         if (pubsub.hasSubscribers(`transaction.completed.${hash}`)) {
-          const result = pubsub.getValue(`transaction.completed.${hash}`);
-          if (result.status !== "fulfilled") {
-            await transactionPoolStore.delete(hash);
+          const result = pubsub.getValue(`transaction.completed.${hash}`)
+          if (result.status !== 'fulfilled') {
+            await transactionPoolStore.delete(hash)
           }
-          result.status === "fulfilled" ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
+          result.status === 'fulfilled' ? resolve(result.hash) : reject({ hash: result.hash, error: result.error })
         } else {
           const completed = async (result) => {
-            if (result.status !== "fulfilled") {
-              await transactionPoolStore.delete(hash);
+            if (result.status !== 'fulfilled') {
+              await transactionPoolStore.delete(hash)
             }
-            result.status === "fulfilled" ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
+            result.status === 'fulfilled' ? resolve(result.hash) : reject({ hash: result.hash, error: result.error })
             setTimeout(async () => {
-              pubsub.unsubscribe(`transaction.completed.${hash}`, completed);
-            }, 1e4);
-          };
-          pubsub.subscribe(`transaction.completed.${hash}`, completed);
+              pubsub.unsubscribe(`transaction.completed.${hash}`, completed)
+            }, 1e4)
+          }
+          pubsub.subscribe(`transaction.completed.${hash}`, completed)
         }
-      });
-      await globalThis.transactionPoolStore.put(hash, message.encoded);
-      this.addPendingNonce(message.decoded.from, message.decoded.nonce);
+      })
+      await globalThis.transactionPoolStore.put(hash, message.encoded)
+      this.addPendingNonce(message.decoded.from, message.decoded.nonce)
       try {
-        peernet.publish("add-transaction", message.encoded);
+        peernet.publish('add-transaction', message.encoded)
       } catch (publishError) {
-        console.warn("peernet publish failed: add-transaction", publishError?.message ?? publishError);
+        console.warn('peernet publish failed: add-transaction', publishError?.message ?? publishError)
       }
-      const fee = await calculateFee(message.decoded);
-      return { hash, data, fee, wait, message };
+      const fee = await calculateFee(message.decoded)
+      return { hash, data, fee, wait, message }
     } catch (error) {
-      console.log("remo");
-      await transactionPoolStore.delete(hash);
-      this.removePendingNonce(message.decoded.from, message.decoded.nonce);
-      throw error;
+      console.log('remo')
+      await transactionPoolStore.delete(hash)
+      this.removePendingNonce(message.decoded.from, message.decoded.nonce)
+      throw error
     }
   }
 }
 
 const isDerivedFrom = (derivedClass, baseClass) => {
-  if (!derivedClass || !baseClass) return false;
-  let proto = Object.getPrototypeOf(derivedClass);
+  if (!derivedClass || !baseClass) return false
+  let proto = Object.getPrototypeOf(derivedClass)
   while (proto) {
-    if (proto === baseClass) return true;
-    proto = Object.getPrototypeOf(proto);
+    if (proto === baseClass) return true
+    proto = Object.getPrototypeOf(proto)
   }
-  return false;
-};
+  return false
+}
 const parseContractInheritance = (contractCode) => {
-  const classMatch = contractCode.match(/class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+  const classMatch = contractCode.match(/class\s+(\w+)(?:\s+extends\s+(\w+))?/)
   if (!classMatch) {
-    return { className: null, baseClass: null, hasInheritance: false };
+    return { className: null, baseClass: null, hasInheritance: false }
   }
   return {
     className: classMatch[1],
     baseClass: classMatch[2] || null,
     hasInheritance: !!classMatch[2]
-  };
-};
+  }
+}
 
 class ContractRegistry {
   constructor() {
-    this.baseContracts = /* @__PURE__ */ new Map();
+    this.baseContracts = /* @__PURE__ */ new Map()
     // hash -> ContractMessage
-    this.contractNames = /* @__PURE__ */ new Map();
+    this.contractNames = /* @__PURE__ */ new Map()
     // name -> hash
-    this.contractDependencies = /* @__PURE__ */ new Map();
+    this.contractDependencies = /* @__PURE__ */ new Map()
   }
   /**
    * Register a base contract that can be reused
@@ -278,13 +304,13 @@ class ContractRegistry {
    * @returns The contract hash
    */
   async registerBaseContract(name, message) {
-    const hash = await message.hash();
-    this.baseContracts.set(hash, message);
-    this.contractNames.set(name, hash);
+    const hash = await message.hash()
+    this.baseContracts.set(hash, message)
+    this.contractNames.set(name, hash)
     if (globalThis.contractStore) {
-      await globalThis.contractStore.put(hash, message.encoded);
+      await globalThis.contractStore.put(hash, message.encoded)
     }
-    return hash;
+    return hash
   }
   /**
    * Register a name for a contract hash in the nameService
@@ -294,9 +320,10 @@ class ContractRegistry {
    * @param signer The wallet to sign the transaction
    */
   async registerNameInNameService(name, hash, chain, signer) {
-    ({
+    ;({
       from: await signer.address,
-      to: addresses.nameService});
+      to: addresses.nameService
+    })
   }
   /**
    * Get a base contract by name
@@ -305,11 +332,11 @@ class ContractRegistry {
    * @returns The contract message or undefined
    */
   getBaseContract(name) {
-    const hash = this.contractNames.get(name);
+    const hash = this.contractNames.get(name)
     if (hash) {
-      return this.baseContracts.get(hash);
+      return this.baseContracts.get(hash)
     }
-    return void 0;
+    return void 0
   }
   /**
    * Get a base contract by hash
@@ -317,7 +344,7 @@ class ContractRegistry {
    * @returns The contract message or undefined
    */
   getBaseContractByHash(hash) {
-    return this.baseContracts.get(hash);
+    return this.baseContracts.get(hash)
   }
   /**
    * Resolve a name to a hash (first local, then nameService)
@@ -325,7 +352,7 @@ class ContractRegistry {
    * @returns The contract hash or undefined
    */
   resolveNameToHash(name) {
-    return this.contractNames.get(name);
+    return this.contractNames.get(name)
   }
   /**
    * Register contract dependencies (inheritance chain)
@@ -333,7 +360,7 @@ class ContractRegistry {
    * @param dependencies Array of base contract hashes this contract depends on
    */
   registerDependencies(contractHash, dependencies) {
-    this.contractDependencies.set(contractHash, dependencies);
+    this.contractDependencies.set(contractHash, dependencies)
   }
   /**
    * Get all dependencies for a contract
@@ -341,7 +368,7 @@ class ContractRegistry {
    * @returns Array of dependency hashes
    */
   getDependencies(contractHash) {
-    return this.contractDependencies.get(contractHash) || [];
+    return this.contractDependencies.get(contractHash) || []
   }
   /**
    * Check if all dependencies for a contract are available
@@ -349,27 +376,27 @@ class ContractRegistry {
    * @returns true if all dependencies are available
    */
   async areDependenciesAvailable(contractHash) {
-    const dependencies = this.getDependencies(contractHash);
-    if (dependencies.length === 0) return true;
+    const dependencies = this.getDependencies(contractHash)
+    if (dependencies.length === 0) return true
     for (const depHash of dependencies) {
       try {
         if (globalThis.contractStore) {
-          await globalThis.contractStore.get(depHash);
+          await globalThis.contractStore.get(depHash)
         } else {
-          return false;
+          return false
         }
       } catch {
-        return false;
+        return false
       }
     }
-    return true;
+    return true
   }
   /**
    * Get all registered contract hashes
    * @returns Array of contract hashes
    */
   getBaseContractHashes() {
-    return Array.from(this.baseContracts.keys());
+    return Array.from(this.baseContracts.keys())
   }
   /**
    * Get hash for a registered name
@@ -377,7 +404,7 @@ class ContractRegistry {
    * @returns The hash or undefined
    */
   getHashForName(name) {
-    return this.contractNames.get(name);
+    return this.contractNames.get(name)
   }
   /**
    * Analyze contract code and extract inheritance information
@@ -385,7 +412,7 @@ class ContractRegistry {
    * @returns Inheritance information
    */
   analyzeContract(contractCode) {
-    return parseContractInheritance(contractCode);
+    return parseContractInheritance(contractCode)
   }
   /**
    * Build a complete contract by combining base contracts
@@ -394,35 +421,35 @@ class ContractRegistry {
    * @returns Combined contract code
    */
   async buildContract(contractCode, baseContractIdentifiers = []) {
-    let combinedCode = "";
+    let combinedCode = ''
     for (const identifier of baseContractIdentifiers) {
-      let baseContract = await this.getBaseContract(identifier);
+      let baseContract = await this.getBaseContract(identifier)
       if (!baseContract) {
-        baseContract = this.getBaseContractByHash(identifier);
+        baseContract = this.getBaseContractByHash(identifier)
       }
       if (baseContract) {
-        const decoded = baseContract.decoded;
+        const decoded = baseContract.decoded
         combinedCode += `// Base contract: ${identifier}
-`;
-        combinedCode += decoded.contract + "\n\n";
+`
+        combinedCode += decoded.contract + '\n\n'
       }
     }
-    combinedCode += contractCode;
-    return combinedCode;
+    combinedCode += contractCode
+    return combinedCode
   }
   /**
    * Clear all registered contracts
    */
   clear() {
-    this.baseContracts.clear();
-    this.contractDependencies.clear();
+    this.baseContracts.clear()
+    this.contractDependencies.clear()
   }
   /**
    * Get all registered base contract names
    * @returns Array of base contract names
    */
   getBaseContractNames() {
-    return Array.from(this.contractNames.keys());
+    return Array.from(this.contractNames.keys())
   }
   /**
    * Get name for a hash if registered
@@ -431,16 +458,16 @@ class ContractRegistry {
    */
   getNameForHash(hash) {
     for (const [name, h] of this.contractNames.entries()) {
-      if (h === hash) return name;
+      if (h === hash) return name
     }
-    return void 0;
+    return void 0
   }
 }
-const contractRegistry = new ContractRegistry();
+const contractRegistry = new ContractRegistry()
 
 class Contract extends Transaction {
   constructor(config) {
-    super(config);
+    super(config)
   }
   /**
    *
@@ -450,7 +477,7 @@ class Contract extends Transaction {
    * @returns lib.createContractMessage
    */
   async createContractMessage(creator, contract, constructorParameters = []) {
-    return createContractMessage(creator, contract, constructorParameters);
+    return createContractMessage(creator, contract, constructorParameters)
   }
   /**
    *
@@ -460,8 +487,8 @@ class Contract extends Transaction {
    * @returns {Address}
    */
   async createContractAddress(creator, contract, constructorParameters = []) {
-    contract = await this.createContractMessage(creator, contract, constructorParameters);
-    return contract.hash();
+    contract = await this.createContractMessage(creator, contract, constructorParameters)
+    return contract.hash()
   }
   /**
    *
@@ -470,8 +497,8 @@ class Contract extends Transaction {
    * @returns
    */
   async deployContract(signer, contract, constructorParameters = []) {
-    const message = await createContractMessage(await signer.address, contract, constructorParameters);
-    return this.deployContractMessage(signer, message);
+    const message = await createContractMessage(await signer.address, contract, constructorParameters)
+    return this.deployContractMessage(signer, message)
   }
   /**
    * Register a base contract for reuse by other contracts
@@ -482,15 +509,15 @@ class Contract extends Transaction {
    * @returns {Promise<string>} The contract hash
    */
   async registerBaseContract(name, contract, constructorParameters = []) {
-    const creator = addresses.contractFactory;
-    const message = await createContractMessage(creator, contract, []);
-    const hash = await contractRegistry.registerBaseContract(name, message);
+    const creator = addresses.contractFactory
+    const message = await createContractMessage(creator, contract, [])
+    const hash = await contractRegistry.registerBaseContract(name, message)
     try {
-      await globalThis.contractStore.put(hash, message.encoded);
+      await globalThis.contractStore.put(hash, message.encoded)
     } catch (error) {
-      throw error;
+      throw error
     }
-    return hash;
+    return hash
   }
   /**
    * Deploy a contract with optional base contracts for inheritance
@@ -502,38 +529,38 @@ class Contract extends Transaction {
    */
   async deployDerivedContract(signer, contract, baseContractIdentifier, constructorParameters = []) {
     if (baseContractIdentifier) {
-      const baseContract = contractRegistry.getBaseContract(baseContractIdentifier);
+      const baseContract = contractRegistry.getBaseContract(baseContractIdentifier)
       if (!baseContract) {
         throw new Error(
           `Base contract '${baseContractIdentifier}' not found. Register it first using registerBaseContract.`
-        );
+        )
       }
     }
-    const inheritanceInfo = parseContractInheritance(contract);
-    const message = await createContractMessage(await signer.address, contract, constructorParameters);
+    const inheritanceInfo = parseContractInheritance(contract)
+    const message = await createContractMessage(await signer.address, contract, constructorParameters)
     if (inheritanceInfo.hasInheritance && inheritanceInfo.baseClass && baseContractIdentifier) {
-      const baseHash = contractRegistry.getHashForName(inheritanceInfo.baseClass);
+      const baseHash = contractRegistry.getHashForName(inheritanceInfo.baseClass)
       if (baseHash) {
-        const contractHash = await message.hash();
-        contractRegistry.registerDependencies(contractHash, [baseHash]);
+        const contractHash = await message.hash()
+        contractRegistry.registerDependencies(contractHash, [baseHash])
       }
     }
-    return this.deployContractMessage(signer, message);
+    return this.deployContractMessage(signer, message)
   }
   async deployContractMessage(signer, message) {
     try {
-      await globalThis.contractStore.put(await message.hash(), message.encoded);
+      await globalThis.contractStore.put(await message.hash(), message.encoded)
     } catch (error) {
-      throw error;
+      throw error
     }
     let transaction = {
       from: await signer.address,
       to: addresses.contractFactory,
-      method: "registerContract",
+      method: 'registerContract',
       params: [await message.hash()]
-    };
-    transaction = await signTransaction(await this.createTransaction(transaction), signer);
-    return this.sendTransaction(transaction);
+    }
+    transaction = await signTransaction(await this.createTransaction(transaction), signer)
+    return this.sendTransaction(transaction)
   }
   /**
    * Check if a class is derived from another class
@@ -542,7 +569,7 @@ class Contract extends Transaction {
    * @returns true if derivedClass extends baseClass
    */
   isDerivedFrom(derivedClass, baseClass) {
-    return isDerivedFrom(derivedClass, baseClass);
+    return isDerivedFrom(derivedClass, baseClass)
   }
   /**
    * Parse contract code to extract inheritance information
@@ -550,25 +577,25 @@ class Contract extends Transaction {
    * @returns Inheritance information
    */
   parseContractInheritance(contractCode) {
-    return parseContractInheritance(contractCode);
+    return parseContractInheritance(contractCode)
   }
   /**
    * Get the contract registry instance
    * @returns {ContractRegistry} The contract registry
    */
   getRegistry() {
-    return contractRegistry;
+    return contractRegistry
   }
 }
 
-const debug$2 = createDebugger("leofcoin/machine");
+const debug$2 = createDebugger('leofcoin/machine')
 class Machine {
   constructor(blocks) {
     this.states = {
       states: {},
       lastBlock: {
         index: -1,
-        hash: ""
+        hash: ''
       },
       accounts: {},
       info: {
@@ -582,156 +609,159 @@ class Machine {
         totalTransactions: BigInt(0),
         totalBlocks: BigInt(0)
       }
-    };
-    this.wantList = [];
+    }
+    this.wantList = []
     this.ready = new Promise((resolve) => {
-      this.readyResolve = resolve;
-    });
-    this.init(blocks);
+      this.readyResolve = resolve
+    })
+    this.init(blocks)
   }
   init(blocks) {
-    return this.#init(blocks);
+    return this.#init(blocks)
   }
   async #onmessage(data) {
     switch (data.type) {
-      case "transactionLoaded": {
-        const { from, nonce, hash } = data.result;
-        await transactionPoolStore.has(hash) && await transactionPoolStore.delete(hash);
+      case 'transactionLoaded': {
+        const { from, nonce, hash } = data.result
+        ;(await transactionPoolStore.has(hash)) && (await transactionPoolStore.delete(hash))
         try {
-          const _nonce = await accountsStore.get(from);
-          if (nonce > _nonce) await accountsStore.put(from, nonce);
+          const _nonce = await accountsStore.get(from)
+          if (nonce > _nonce) await accountsStore.put(from, nonce)
         } catch (error) {
-          await accountsStore.put(from, nonce);
+          await accountsStore.put(from, nonce)
         }
-        break;
+        break
       }
-      case "contractError": {
-        console.warn(data.error);
-        console.warn(`contract error: ${data.hash}`);
-        await contractStore.delete(data.hash);
-        break;
+      case 'contractError': {
+        console.warn(data.error)
+        console.warn(`contract error: ${data.hash}`)
+        await contractStore.delete(data.hash)
+        break
       }
-      case "initError": {
-        console.error(`init error: ${data.message}`);
-        break;
+      case 'initError': {
+        console.error(`init error: ${data.message}`)
+        break
       }
-      case "executeError": {
-        pubsub.publish(data.id, { error: data.message });
-        break;
+      case 'executeError': {
+        pubsub.publish(data.id, { error: data.message })
+        break
       }
-      case "debug": {
-        if (data.message.includes("loaded transactions for block:")) {
-          pubsub.publish("block-loaded", data.message.replace("loaded transactions for block: ", "").split(" @")[0]);
+      case 'debug': {
+        if (data.message.includes('loaded transactions for block:')) {
+          pubsub.publish('block-loaded', data.message.replace('loaded transactions for block: ', '').split(' @')[0])
         }
-        break;
+        break
       }
-      case "error": {
-        console.error(data.message);
-        break;
+      case 'error': {
+        console.error(data.message)
+        break
       }
-      case "machine-ready": {
-        pubsub.publish("machine.ready", true);
-        break;
+      case 'machine-ready': {
+        pubsub.publish('machine.ready', true)
+        break
       }
-      case "response": {
-        pubsub.publish(data.id, data.value || false);
-        break;
+      case 'response': {
+        pubsub.publish(data.id, data.value || false)
+        break
       }
-      case "addToWantList": {
-        this.wantList.push(data.hash);
+      case 'addToWantList': {
+        this.wantList.push(data.hash)
       }
-      case "ask": {
-        if (data.question === "contract" || data.question === "transaction") {
+      case 'ask': {
+        if (data.question === 'contract' || data.question === 'transaction') {
           try {
-            const input = await peernet.get(data.input, data.question);
+            const input = await peernet.get(data.input, data.question)
             if (input === void 0) {
-              this.worker.postMessage({ id: data.id, error: `could not get ${data.question} @${data.input}` });
-              this.wantList.push(data.input);
+              this.worker.postMessage({ id: data.id, error: `could not get ${data.question} @${data.input}` })
+              this.wantList.push(data.input)
             } else {
-              this.worker.postMessage({ id: data.id, input });
+              this.worker.postMessage({ id: data.id, input })
             }
           } catch (error) {
-            console.error(error);
-            this.worker.postMessage({ id: data.id, error: `could not get ${data.question} @${data.input}` });
-            this.wantList.push(data.input);
+            console.error(error)
+            this.worker.postMessage({ id: data.id, error: `could not get ${data.question} @${data.input}` })
+            this.wantList.push(data.input)
           }
-        } else if (data.question === "peers") {
+        } else if (data.question === 'peers') {
           this.worker.postMessage({
             id: data.id,
             input: peernet.connections ? Object.entries(peernet.connections).map(([id, peer]) => peer.toJSON()) : []
-          });
+          })
         } else {
-          this.worker.postMessage({ id: data.id, input: data.input });
+          this.worker.postMessage({ id: data.id, input: data.input })
         }
       }
     }
   }
   async updateState() {
     try {
-      const lastBlock = await this.lastBlock;
-      const lastBlockIndex = Number(lastBlock.index);
-      const statesLastBlockIndex = Number(this.states.lastBlock.index);
-      if (lastBlockIndex > statesLastBlockIndex || lastBlock.hash !== this.states.lastBlock.hash && Number(lastBlockIndex) === 0) {
-        const blocks = (await this.blocks).slice(statesLastBlockIndex);
-        let transactions = [];
+      const lastBlock = await this.lastBlock
+      const lastBlockIndex = Number(lastBlock.index)
+      const statesLastBlockIndex = Number(this.states.lastBlock.index)
+      if (
+        lastBlockIndex > statesLastBlockIndex ||
+        (lastBlock.hash !== this.states.lastBlock.hash && Number(lastBlockIndex) === 0)
+      ) {
+        const blocks = (await this.blocks).slice(statesLastBlockIndex)
+        let transactions = []
         for (const block of blocks) {
-          if (block?.transactions) transactions = [...transactions, ...block.transactions];
+          if (block?.transactions) transactions = [...transactions, ...block.transactions]
         }
         transactions = await Promise.all(
           transactions.map(async (transaction) => new TransactionMessage(await transactionStore.get(transaction)))
-        );
+        )
         const contractsToGet = transactions.reduce((set, current) => {
-          const contract = current.decoded.to;
-          if (!set.includes(contract)) set.push(contract);
-          return set;
-        }, []);
-        const state = {};
-        if (!contractsToGet.includes(addresses.contractFactory)) contractsToGet.push(addresses.contractFactory);
-        if (!contractsToGet.includes(addresses.nativeToken)) contractsToGet.push(addresses.nativeToken);
-        if (!contractsToGet.includes(addresses.nameService)) contractsToGet.push(addresses.nameService);
-        if (!contractsToGet.includes(addresses.validators)) contractsToGet.push(addresses.validators);
+          const contract = current.decoded.to
+          if (!set.includes(contract)) set.push(contract)
+          return set
+        }, [])
+        const state = {}
+        if (!contractsToGet.includes(addresses.contractFactory)) contractsToGet.push(addresses.contractFactory)
+        if (!contractsToGet.includes(addresses.nativeToken)) contractsToGet.push(addresses.nativeToken)
+        if (!contractsToGet.includes(addresses.nameService)) contractsToGet.push(addresses.nameService)
+        if (!contractsToGet.includes(addresses.validators)) contractsToGet.push(addresses.validators)
         await Promise.all(
           contractsToGet.map(async (contract) => {
-            const value = await this.#askWorker("get", { contract, method: "state", params: [] });
-            state[contract] = value;
+            const value = await this.#askWorker('get', { contract, method: 'state', params: [] })
+            state[contract] = value
           })
-        );
-        let accounts = {};
+        )
+        let accounts = {}
         try {
-          const promises = [];
+          const promises = []
           for (const address of await accountsStore.keys()) {
             promises.push(async () => {
-              accounts[address] = await accountsStore.get(address);
-            });
+              accounts[address] = await accountsStore.get(address)
+            })
           }
-          await Promise.all(promises);
+          await Promise.all(promises)
         } catch (error) {
-          const promises = [];
+          const promises = []
           for (const transaction of transactions.reverse()) {
-            const { from, to, amount, nonce } = transaction.decoded.data;
+            const { from, to, amount, nonce } = transaction.decoded.data
             if (!accounts[from]) {
-              accounts[from] = nonce;
+              accounts[from] = nonce
               promises.push(async () => {
-                await accountsStore.put(from, nonce);
-              });
+                await accountsStore.put(from, nonce)
+              })
             }
           }
-          await Promise.all(promises);
+          await Promise.all(promises)
         }
         const sortedStringify = (obj, replacer) => {
-          const sorted = {};
-          const keys = Object.keys(obj).sort();
+          const sorted = {}
+          const keys = Object.keys(obj).sort()
           for (const key of keys) {
-            sorted[key] = obj[key];
+            sorted[key] = obj[key]
           }
-          return JSON.stringify(sorted, replacer);
-        };
+          return JSON.stringify(sorted, replacer)
+        }
         const tasks = [
-          stateStore.put("lastBlock", sortedStringify(await this.lastBlock, jsonStringifyBigInt)),
-          stateStore.put("states", sortedStringify(state, jsonStringifyBigInt)),
-          stateStore.put("accounts", sortedStringify(accounts, jsonStringifyBigInt)),
+          stateStore.put('lastBlock', sortedStringify(await this.lastBlock, jsonStringifyBigInt)),
+          stateStore.put('states', sortedStringify(state, jsonStringifyBigInt)),
+          stateStore.put('accounts', sortedStringify(accounts, jsonStringifyBigInt)),
           stateStore.put(
-            "info",
+            'info',
             sortedStringify(
               {
                 nativeBurnAmount: await this.totalBurnAmount,
@@ -749,53 +779,53 @@ class Machine {
             )
           )
           // accountsStore.clear()
-        ];
-        await Promise.all(tasks);
+        ]
+        await Promise.all(tasks)
       }
     } catch (error) {
-      console.error(error);
+      console.error(error)
     }
   }
   async #init(blocks) {
     return new Promise(async (resolve) => {
       const machineReady = async () => {
-        pubsub.unsubscribe("machine.ready", machineReady);
-        await this.updateState();
-        resolve(this);
-      };
-      pubsub.subscribe("machine.ready", machineReady);
-      let pre;
+        pubsub.unsubscribe('machine.ready', machineReady)
+        await this.updateState()
+        resolve(this)
+      }
+      pubsub.subscribe('machine.ready', machineReady)
+      let pre
       try {
-        const importee = await import('url');
-        const url = importee.default;
-        if (url) pre = url.fileURLToPath(new URL(".", import.meta.url));
+        const importee = await import('url')
+        const url = importee.default
+        if (url) pre = url.fileURLToPath(new URL('.', import.meta.url))
       } catch {
-        pre = "./";
-      }
-      this.worker = await new EasyWorker(pre + "workers/machine-worker.js", {
-        serialization: "advanced",
-        type: "module"
-      });
-      this.worker.onmessage(this.#onmessage.bind(this));
-      let rawLastBlock;
-      let rawStates;
-      let rawAccounts;
-      let rawInfo;
-      if (await stateStore.has("lastBlock")) {
-        const decoder = new TextDecoder();
-        const decode = (param) => decoder.decode(param);
-        rawLastBlock = decode(await stateStore.get("lastBlock"));
-        this.states.lastBlock = JSON.parse(rawLastBlock, jsonParseBigInt);
+        pre = './'
+      }
+      this.worker = await new EasyWorker(pre + 'workers/machine-worker.js', {
+        serialization: 'advanced',
+        type: 'module'
+      })
+      this.worker.onmessage(this.#onmessage.bind(this))
+      let rawLastBlock
+      let rawStates
+      let rawAccounts
+      let rawInfo
+      if (await stateStore.has('lastBlock')) {
+        const decoder = new TextDecoder()
+        const decode = (param) => decoder.decode(param)
+        rawLastBlock = decode(await stateStore.get('lastBlock'))
+        this.states.lastBlock = JSON.parse(rawLastBlock, jsonParseBigInt)
         try {
-          rawStates = decode(await stateStore.get("states"));
-          rawAccounts = decode(await stateStore.get("accounts"));
-          rawInfo = decode(await stateStore.get("info"));
-          this.states.states = JSON.parse(rawStates, jsonParseBigInt);
-          this.states.accounts = JSON.parse(rawAccounts, jsonParseBigInt);
-          this.states.info = JSON.parse(rawInfo, jsonParseBigInt);
+          rawStates = decode(await stateStore.get('states'))
+          rawAccounts = decode(await stateStore.get('accounts'))
+          rawInfo = decode(await stateStore.get('info'))
+          this.states.states = JSON.parse(rawStates, jsonParseBigInt)
+          this.states.accounts = JSON.parse(rawAccounts, jsonParseBigInt)
+          this.states.info = JSON.parse(rawInfo, jsonParseBigInt)
         } catch (error) {
-          console.error(error);
-          this.states.accounts = {};
+          console.error(error)
+          this.states.accounts = {}
           this.states.info = {
             nativeCalls: BigInt(0),
             nativeMints: BigInt(0),
@@ -806,13 +836,13 @@ class Machine {
             totalTransferAmount: BigInt(0),
             totalTransactions: BigInt(0),
             totalBlocks: BigInt(0)
-          };
-          rawInfo = JSON.stringify(this.states.info, jsonStringifyBigInt);
-          await stateStore.put("info", new TextEncoder().encode(rawInfo));
+          }
+          rawInfo = JSON.stringify(this.states.info, jsonStringifyBigInt)
+          await stateStore.put('info', new TextEncoder().encode(rawInfo))
         }
       }
       const message = {
-        type: "init",
+        type: 'init',
         input: {
           blocks,
           fromState: this.states.lastBlock?.index >= 0,
@@ -822,31 +852,31 @@ class Machine {
           // @ts-ignore
           peerid: peernet.peerId
         }
-      };
-      this.worker.postMessage(message);
-      this.readyResolve(this);
-    });
+      }
+      this.worker.postMessage(message)
+      this.readyResolve(this)
+    })
   }
   async #runContract(contractMessage) {
-    const hash = await contractMessage.hash();
+    const hash = await contractMessage.hash()
     return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString("hex");
+      const id = randombytes(20).toString('hex')
       const onmessage = (message) => {
-        pubsub.unsubscribe(id, onmessage);
-        if (message?.error) reject(message.error);
-        else resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
+        pubsub.unsubscribe(id, onmessage)
+        if (message?.error) reject(message.error)
+        else resolve(message)
+      }
+      pubsub.subscribe(id, onmessage)
       this.worker.postMessage({
-        type: "run",
+        type: 'run',
         id,
         input: {
           decoded: contractMessage.decoded,
           encoded: contractMessage.encoded,
           hash
         }
-      });
-    });
+      })
+    })
   }
   /**
    *
@@ -857,40 +887,40 @@ class Machine {
    */
   async execute(contract, method, parameters) {
     try {
-      if (contract === contractFactory && method === "registerContract") {
-        if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`);
-        let message;
-        if (!await globalThis.contractStore.has(parameters[0])) {
-          message = await peernet.get(parameters[0], "contract");
-          if (!message) throw new Error(`contract ${parameters[0]} not available`);
-          message = await new ContractMessage(message);
-          await globalThis.contractStore.put(await message.hash(), message.encoded);
+      if (contract === contractFactory && method === 'registerContract') {
+        if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`)
+        let message
+        if (!(await globalThis.contractStore.has(parameters[0]))) {
+          message = await peernet.get(parameters[0], 'contract')
+          if (!message) throw new Error(`contract ${parameters[0]} not available`)
+          message = await new ContractMessage(message)
+          await globalThis.contractStore.put(await message.hash(), message.encoded)
         }
         if (!message) {
-          message = await globalThis.contractStore.get(parameters[0]);
-          message = await new ContractMessage(message);
+          message = await globalThis.contractStore.get(parameters[0])
+          message = await new ContractMessage(message)
         }
-        if (!await this.has(await message.hash())) await this.#runContract(message);
+        if (!(await this.has(await message.hash()))) await this.#runContract(message)
       }
     } catch (error) {
       throw new ContractDeploymentError(`contract deployment failed for ${parameters[0]}
-${error.message}`);
+${error.message}`)
     }
     return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString("hex");
+      const id = randombytes(20).toString('hex')
       const timeout = setTimeout(() => {
-        pubsub.unsubscribe(id, onmessage);
-        reject(new Error(`Machine.execute timeout for ${contract}.${method}`));
-      }, 3e4);
+        pubsub.unsubscribe(id, onmessage)
+        reject(new Error(`Machine.execute timeout for ${contract}.${method}`))
+      }, 3e4)
       const onmessage = (message) => {
-        clearTimeout(timeout);
-        pubsub.unsubscribe(id, onmessage);
-        if (message?.error) reject(new ExecutionError(message.error));
-        else resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
+        clearTimeout(timeout)
+        pubsub.unsubscribe(id, onmessage)
+        if (message?.error) reject(new ExecutionError(message.error))
+        else resolve(message)
+      }
+      pubsub.subscribe(id, onmessage)
       this.worker.postMessage({
-        type: "execute",
+        type: 'execute',
         id,
         input: {
           to: contract,
@@ -898,753 +928,764 @@ ${error.message}`);
           method,
           params: parameters
         }
-      });
-    });
+      })
+    })
   }
   get(contract, method, parameters) {
     return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString();
+      const id = randombytes(20).toString()
       const timeout = setTimeout(() => {
-        pubsub.unsubscribe(id, onmessage);
-        reject(new Error(`Machine.get timeout for ${contract}.${method}`));
-      }, 3e4);
+        pubsub.unsubscribe(id, onmessage)
+        reject(new Error(`Machine.get timeout for ${contract}.${method}`))
+      }, 3e4)
       const onmessage = (message) => {
-        clearTimeout(timeout);
-        pubsub.unsubscribe(id, onmessage);
-        resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
+        clearTimeout(timeout)
+        pubsub.unsubscribe(id, onmessage)
+        resolve(message)
+      }
+      pubsub.subscribe(id, onmessage)
       this.worker.postMessage({
-        type: "get",
+        type: 'get',
         id,
         input: {
           contract,
           method,
           params: parameters
         }
-      });
-    });
+      })
+    })
   }
   async has(address) {
     return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString("hex");
+      const id = randombytes(20).toString('hex')
       const timeout = setTimeout(() => {
-        pubsub.unsubscribe(id, onmessage);
-        reject(new Error(`Machine.has timeout for ${address}`));
-      }, 1e4);
+        pubsub.unsubscribe(id, onmessage)
+        reject(new Error(`Machine.has timeout for ${address}`))
+      }, 1e4)
       const onmessage = (message) => {
-        clearTimeout(timeout);
-        pubsub.unsubscribe(id, onmessage);
-        if (message?.error) reject(message.error);
-        else resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
+        clearTimeout(timeout)
+        pubsub.unsubscribe(id, onmessage)
+        if (message?.error) reject(message.error)
+        else resolve(message)
+      }
+      pubsub.subscribe(id, onmessage)
       this.worker.postMessage({
-        type: "has",
+        type: 'has',
         id,
         input: {
           address
         }
-      });
-    });
+      })
+    })
   }
   #askWorker(type, input) {
     return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString("hex");
+      const id = randombytes(20).toString('hex')
       const timeout = setTimeout(() => {
-        pubsub.unsubscribe(id, onmessage);
-        reject(new Error(`Machine.#askWorker timeout for ${type}`));
-      }, 3e4);
+        pubsub.unsubscribe(id, onmessage)
+        reject(new Error(`Machine.#askWorker timeout for ${type}`))
+      }, 3e4)
       const onmessage = (message) => {
-        clearTimeout(timeout);
-        pubsub.unsubscribe(id, onmessage);
-        if (message?.error) reject(message.error);
-        else resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
+        clearTimeout(timeout)
+        pubsub.unsubscribe(id, onmessage)
+        if (message?.error) reject(message.error)
+        else resolve(message)
+      }
+      pubsub.subscribe(id, onmessage)
       this.worker.postMessage({
         type,
         id,
         input
-      });
-    });
+      })
+    })
   }
   get contracts() {
-    return this.#askWorker("contracts");
+    return this.#askWorker('contracts')
   }
   get totalContracts() {
-    return this.#askWorker("totalContracts");
+    return this.#askWorker('totalContracts')
   }
   get nativeCalls() {
-    return this.#askWorker("nativeCalls");
+    return this.#askWorker('nativeCalls')
   }
   get nativeMints() {
-    return this.#askWorker("nativeMints");
+    return this.#askWorker('nativeMints')
   }
   get nativeBurns() {
-    return this.#askWorker("nativeBurns");
+    return this.#askWorker('nativeBurns')
   }
   get nativeTransfers() {
-    return this.#askWorker("nativeTransfers");
+    return this.#askWorker('nativeTransfers')
   }
   get totalBurnAmount() {
-    return this.#askWorker("totalBurnAmount");
+    return this.#askWorker('totalBurnAmount')
   }
   get totalMintAmount() {
-    return this.#askWorker("totalMintAmount");
+    return this.#askWorker('totalMintAmount')
   }
   get totalTransferAmount() {
-    return this.#askWorker("totalTransferAmount");
+    return this.#askWorker('totalTransferAmount')
   }
   get totalTransactions() {
-    return this.#askWorker("totalTransactions");
+    return this.#askWorker('totalTransactions')
   }
   get totalBlocks() {
-    return this.#askWorker("totalBlocks");
+    return this.#askWorker('totalBlocks')
   }
   get blocks() {
-    return this.getBlocks();
+    return this.getBlocks()
   }
   get lastBlock() {
-    return this.#askWorker("lastBlock").catch((error) => {
-      debug$2("lastBlock fallback after worker timeout:", error?.message ?? error);
-      return this.states.lastBlock;
-    });
+    return this.#askWorker('lastBlock').catch((error) => {
+      debug$2('lastBlock fallback after worker timeout:', error?.message ?? error)
+      return this.states.lastBlock
+    })
   }
   get lastBlockHeight() {
-    return this.#askWorker("lastBlockHeight").catch((error) => {
-      debug$2("lastBlockHeight fallback after worker timeout:", error?.message ?? error);
-      return Number(this.states.lastBlock?.index ?? 0);
-    });
+    return this.#askWorker('lastBlockHeight').catch((error) => {
+      debug$2('lastBlockHeight fallback after worker timeout:', error?.message ?? error)
+      return Number(this.states.lastBlock?.index ?? 0)
+    })
   }
   getBlocks(from, to) {
-    return this.#askWorker("blocks", { from, to });
+    return this.#askWorker('blocks', { from, to })
   }
   getBlock(index) {
-    return this.#askWorker("block", index);
+    return this.#askWorker('block', index)
   }
   async addLoadedBlock(block) {
-    debug$2(`adding loaded block: ${block.index}@${block.hash}`);
-    if (block.decoded) block = { ...block.decoded, hash: await block.hash() };
-    return this.#askWorker("addLoadedBlock", JSON.stringify(block, jsonStringifyBigInt));
+    debug$2(`adding loaded block: ${block.index}@${block.hash}`)
+    if (block.decoded) block = { ...block.decoded, hash: await block.hash() }
+    return this.#askWorker('addLoadedBlock', JSON.stringify(block, jsonStringifyBigInt))
   }
   async latestTransactions() {
-    return this.#askWorker("latestTransactions");
+    return this.#askWorker('latestTransactions')
   }
   async delete(hash) {
-    return globalThis.contractStore.delete(hash);
+    return globalThis.contractStore.delete(hash)
   }
   /**
    *
    * @returns Promise
    */
   async deleteAll() {
-    let hashes = await globalThis.contractStore.keys();
-    hashes = Object.keys(hashes).map((hash) => this.delete(hash));
-    return Promise.all(hashes);
+    let hashes = await globalThis.contractStore.keys()
+    hashes = Object.keys(hashes).map((hash) => this.delete(hash))
+    return Promise.all(hashes)
   }
 }
 
 class Jobber {
   constructor(timeout) {
-    this.busy = false;
-    this.timeout = timeout;
+    this.busy = false
+    this.timeout = timeout
   }
   add(fn) {
-    this.busy = true;
+    this.busy = true
     return new Promise(async (resolve, reject) => {
       const timeout = setTimeout(() => {
-        reject("timeout");
-      }, this.timeout);
+        reject('timeout')
+      }, this.timeout)
       this.destroy = () => {
-        clearTimeout(timeout);
-        this.busy = false;
-        resolve("stopped");
-      };
+        clearTimeout(timeout)
+        this.busy = false
+        resolve('stopped')
+      }
       try {
-        const result = await fn();
-        clearTimeout(timeout);
-        this.busy = false;
-        resolve(result);
+        const result = await fn()
+        clearTimeout(timeout)
+        this.busy = false
+        resolve(result)
       } catch (error) {
-        clearTimeout(timeout);
-        reject(error);
+        clearTimeout(timeout)
+        reject(error)
       }
-    });
+    })
   }
 }
 
-const debug$1 = createDebugger("leofcoin/state");
+const debug$1 = createDebugger('leofcoin/state')
 class State extends Contract {
   constructor(config) {
-    super(config);
-    this.#lastResolvedTime = 0;
-    this.#resolving = false;
-    this.#resolveErrorCount = 0;
-    this.#chainState = "loading";
-    this.#syncErrorCount = 0;
-    this.#blockHashMap = /* @__PURE__ */ new Map();
-    this.#chainSyncing = false;
-    this.#blocks = [];
-    this.knownBlocks = [];
-    this.#totalSize = 0;
-    this.#loaded = false;
-    this.#resolvingHashes = /* @__PURE__ */ new Set();
-    this._wantList = [];
+    super(config)
+    this.#lastResolvedTime = 0
+    this.#resolving = false
+    this.#resolveErrorCount = 0
+    this.#chainState = 'loading'
+    this.#syncErrorCount = 0
+    this.#blockHashMap = /* @__PURE__ */ new Map()
+    this.#chainSyncing = false
+    this.#blocks = []
+    this.knownBlocks = []
+    this.#totalSize = 0
+    this.#loaded = false
+    this.#resolvingHashes = /* @__PURE__ */ new Set()
+    this._wantList = []
     this.#chainStateHandler = () => {
-      return new globalThis.peernet.protos["peernet-response"]({
+      return new globalThis.peernet.protos['peernet-response']({
         response: this.#chainState
-      });
-    };
+      })
+    }
     this.#lastBlockHandler = async () => {
-      return new globalThis.peernet.protos["peernet-response"]({
+      return new globalThis.peernet.protos['peernet-response']({
         response: new LastBlockMessage(await this.lastBlock).encoded
-      });
-    };
+      })
+    }
     this.#knownBlocksHandler = async () => {
-      return new globalThis.peernet.protos["peernet-response"]({
+      return new globalThis.peernet.protos['peernet-response']({
         response: { blocks: await globalThis.blockStore.keys() }
-      });
-    };
-    this.#loadBlockTransactions = (transactions) => Promise.all(
-      transactions.map(async (transaction) => new TransactionMessage(await peernet.get(transaction, "transaction")))
-    );
+      })
+    }
+    this.#loadBlockTransactions = (transactions) =>
+      Promise.all(
+        transactions.map(async (transaction) => new TransactionMessage(await peernet.get(transaction, 'transaction')))
+      )
     this.#getLastTransactions = async () => {
-      let lastTransactions = (await Promise.all(
-        (await this.blocks).filter((block) => block.loaded).slice(-24).map((block) => this.#loadBlockTransactions(block.transactions))
-      )).reduce((all, transactions) => [...all, ...transactions], []);
-      return Promise.all(lastTransactions.map((transaction) => transaction.hash()));
-    };
-  }
-  #resolveErrored;
-  #lastResolvedTime;
-  #lastResolved;
-  #resolving;
-  #resolveErrorCount;
-  #syncState;
-  #chainState;
-  #lastBlockInQue;
-  #syncErrorCount;
-  #blockHashMap;
-  #chainSyncing;
-  #blocks;
-  #totalSize;
-  #machine;
-  #loaded;
-  #resolvingHashes;
+      let lastTransactions = (
+        await Promise.all(
+          (
+            await this.blocks
+          )
+            .filter((block) => block.loaded)
+            .slice(-24)
+            .map((block) => this.#loadBlockTransactions(block.transactions))
+        )
+      ).reduce((all, transactions) => [...all, ...transactions], [])
+      return Promise.all(lastTransactions.map((transaction) => transaction.hash()))
+    }
+  }
+  #resolveErrored
+  #lastResolvedTime
+  #lastResolved
+  #resolving
+  #resolveErrorCount
+  #syncState
+  #chainState
+  #lastBlockInQue
+  #syncErrorCount
+  #blockHashMap
+  #chainSyncing
+  #blocks
+  #totalSize
+  #machine
+  #loaded
+  #resolvingHashes
   /**
    * contains transactions we need before we can successfully load
    */
   get wantList() {
-    return this.#machine?.wantList ?? this._wantList;
+    return this.#machine?.wantList ?? this._wantList
   }
   get state() {
     return {
       sync: this.#syncState,
       chain: this.#chainState
-    };
+    }
   }
   get blockHashMap() {
-    return this.#blockHashMap.entries();
+    return this.#blockHashMap.entries()
   }
   get loaded() {
-    return this.#loaded;
+    return this.#loaded
   }
   get resolving() {
-    return this.#resolving;
+    return this.#resolving
   }
   get contracts() {
-    return this.#machine.contracts;
+    return this.#machine.contracts
   }
   get totalContracts() {
-    return this.#machine.totalContracts;
+    return this.#machine.totalContracts
   }
   get nativeCalls() {
-    return this.#machine.nativeCalls;
+    return this.#machine.nativeCalls
   }
   get nativeMints() {
-    return this.#machine.nativeMints;
+    return this.#machine.nativeMints
   }
   get nativeBurns() {
-    return this.#machine.nativeBurns;
+    return this.#machine.nativeBurns
   }
   get nativeTransfers() {
-    return this.#machine.nativeTransfers;
+    return this.#machine.nativeTransfers
   }
   get totalBurnAmouint() {
-    return this.#machine.totalBurnAmount;
+    return this.#machine.totalBurnAmount
   }
   get totalMintAmount() {
-    return this.#machine.totalMintAmount;
+    return this.#machine.totalMintAmount
   }
   get totalTransferAmount() {
-    return this.#machine.totalTransferAmount;
+    return this.#machine.totalTransferAmount
   }
   get totalTransactions() {
-    return this.#machine.totalTransactions;
+    return this.#machine.totalTransactions
   }
   get totalBlocks() {
-    return this.#machine.totalBlocks;
+    return this.#machine.totalBlocks
   }
   get blocks() {
-    return this.getBlocks();
+    return this.getBlocks()
   }
   get lastBlock() {
-    return this.#machine ? this.#machine.lastBlock : { index: 0, hash: "0x0", previousHash: "0x0" };
+    return this.#machine ? this.#machine.lastBlock : { index: 0, hash: '0x0', previousHash: '0x0' }
   }
   get lastBlockHeight() {
-    return this.#machine ? this.#machine.lastBlockHeight : 0;
+    return this.#machine ? this.#machine.lastBlockHeight : 0
   }
   getBlock(index) {
-    return this.#machine.getBlock(index);
+    return this.#machine.getBlock(index)
   }
   getBlocks(from, to) {
-    return this.#machine.getBlocks(from, to);
+    return this.#machine.getBlocks(from, to)
   }
   get totalSize() {
-    return this.#totalSize;
+    return this.#totalSize
   }
   get machine() {
-    return this.#machine;
+    return this.#machine
   }
   async clearPool() {
-    await globalThis.transactionPoolStore.clear();
+    await globalThis.transactionPoolStore.clear()
   }
   /**
    * drastic measurement, removes everything!
    */
   async clearAll() {
-    await globalThis.accountsStore.clear();
-    await globalThis.chainStore.clear();
-    await globalThis.blockStore.clear();
-    await globalThis.transactionStore.clear();
-    await globalThis.stateStore.clear();
-    await globalThis.transactionPoolStore.clear();
-  }
-  #chainStateHandler;
-  #lastBlockHandler;
-  #knownBlocksHandler;
+    await globalThis.accountsStore.clear()
+    await globalThis.chainStore.clear()
+    await globalThis.blockStore.clear()
+    await globalThis.transactionStore.clear()
+    await globalThis.stateStore.clear()
+    await globalThis.transactionPoolStore.clear()
+  }
+  #chainStateHandler
+  #lastBlockHandler
+  #knownBlocksHandler
   async init() {
-    console.log("State init start");
-    this.jobber = new Jobber(this.resolveTimeout);
-    await globalThis.peernet.addRequestHandler("lastBlock", this.#lastBlockHandler);
-    await globalThis.peernet.addRequestHandler("knownBlocks", this.#knownBlocksHandler);
-    await globalThis.peernet.addRequestHandler("chainState", this.#chainStateHandler);
-    let localBlockHash;
-    let blockMessage;
-    let localBlock;
-    console.log("State init before try-catch");
+    console.log('State init start')
+    this.jobber = new Jobber(this.resolveTimeout)
+    await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler)
+    await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler)
+    await globalThis.peernet.addRequestHandler('chainState', this.#chainStateHandler)
+    let localBlockHash
+    let blockMessage
+    let localBlock
+    console.log('State init before try-catch')
     try {
-      const rawBlock = await globalThis.chainStore.has("lastBlock");
-      console.log("State init after has lastBlock check");
+      const rawBlock = await globalThis.chainStore.has('lastBlock')
+      console.log('State init after has lastBlock check')
       if (rawBlock) {
-        console.log("State init after has lastBlock found");
-        console.log(rawBlock);
-        localBlockHash = new TextDecoder().decode(await globalThis.chainStore.get("lastBlock"));
-        console.log(localBlockHash);
-        if (localBlockHash !== "0x0") {
-          blockMessage = await globalThis.blockStore.get(localBlockHash);
-          console.log(blockMessage);
-          blockMessage = await new BlockMessage(blockMessage);
-          localBlock = { ...blockMessage.decoded, hash: localBlockHash };
+        console.log('State init after has lastBlock found')
+        console.log(rawBlock)
+        localBlockHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'))
+        console.log(localBlockHash)
+        if (localBlockHash !== '0x0') {
+          blockMessage = await globalThis.blockStore.get(localBlockHash)
+          console.log(blockMessage)
+          blockMessage = await new BlockMessage(blockMessage)
+          localBlock = { ...blockMessage.decoded, hash: localBlockHash }
         }
-        console.log("State init after localBlock set");
+        console.log('State init after localBlock set')
       } else {
-        localBlock = { index: 0, hash: "0x0", previousHash: "0x0" };
+        localBlock = { index: 0, hash: '0x0', previousHash: '0x0' }
       }
     } catch {
-      console.log("e");
-      console.log("State init middle");
-      localBlock = { index: 0, hash: "0x0", previousHash: "0x0" };
+      console.log('e')
+      console.log('State init middle')
+      localBlock = { index: 0, hash: '0x0', previousHash: '0x0' }
     }
-    console.log("State init middle");
+    console.log('State init middle')
     try {
-      console.log("fetching known blocks from blockStore");
-      this.knownBlocks = await blockStore.keys();
+      console.log('fetching known blocks from blockStore')
+      this.knownBlocks = await blockStore.keys()
     } catch (error) {
-      console.log("no local known blocks found");
+      console.log('no local known blocks found')
     }
     try {
-      if (localBlock?.hash && localBlock.hash !== "0x0") {
+      if (localBlock?.hash && localBlock.hash !== '0x0') {
         try {
-          if (!await globalThis.stateStore.has("lastBlock")) {
-            await this.resolveBlocks();
+          if (!(await globalThis.stateStore.has('lastBlock'))) {
+            await this.resolveBlocks()
           }
         } catch {
-          await this.resolveBlocks();
+          await this.resolveBlocks()
         }
       } else {
-        await this.resolveBlocks();
+        await this.resolveBlocks()
       }
-      const machine = new Machine(this.#blocks);
-      console.log(machine);
-      await machine.ready;
-      this.#machine = machine;
-      const lastBlock = await this.#machine.lastBlock;
-      if (lastBlock.hash !== "0x0") {
-        this.updateState(new BlockMessage(lastBlock));
+      const machine = new Machine(this.#blocks)
+      console.log(machine)
+      await machine.ready
+      this.#machine = machine
+      const lastBlock = await this.#machine.lastBlock
+      if (lastBlock.hash !== '0x0') {
+        this.updateState(new BlockMessage(lastBlock))
       }
-      this.#loaded = true;
+      this.#loaded = true
     } catch (error) {
-      console.log("e");
+      console.log('e')
       if (isResolveError(error)) {
-        console.error(error);
+        console.error(error)
       }
-      console.log(error);
+      console.log(error)
     }
   }
   async updateState(message) {
     try {
-      const hash = await message.hash();
-      await globalThis.chainStore.put("lastBlock", hash);
-      globalThis.pubsub.publish("lastBlock", message.encoded);
+      const hash = await message.hash()
+      await globalThis.chainStore.put('lastBlock', hash)
+      globalThis.pubsub.publish('lastBlock', message.encoded)
       if (!this.#machine) {
-        const machine = new Machine(this.#blocks);
-        console.log(machine);
-        await machine.ready;
-        this.#machine = machine;
+        const machine = new Machine(this.#blocks)
+        console.log(machine)
+        await machine.ready
+        this.#machine = machine
       }
-      await this.#machine.updateState();
+      await this.#machine.updateState()
     } catch (error) {
-      console.error(error);
+      console.error(error)
     }
   }
   getLatestBlock() {
-    return this.#getLatestBlock();
+    return this.#getLatestBlock()
   }
   async getAndPutBlock(hash) {
-    let block = await globalThis.peernet.get(hash, "block");
+    let block = await globalThis.peernet.get(hash, 'block')
     if (block !== void 0) {
       if (!(block instanceof Uint8Array)) {
-        block = new Uint8Array(Object.values(block));
+        block = new Uint8Array(Object.values(block))
       }
-      block = await new BlockMessage(block);
-      const { index } = block.decoded;
-      if (this.#blocks[index] && this.#blocks[index].hash !== block.hash) throw `invalid block ${hash} @${index}`;
-      if (!await globalThis.peernet.has(hash)) await globalThis.peernet.put(hash, block.encoded, "block");
+      block = await new BlockMessage(block)
+      const { index } = block.decoded
+      if (this.#blocks[index] && this.#blocks[index].hash !== block.hash) throw `invalid block ${hash} @${index}`
+      if (!(await globalThis.peernet.has(hash))) await globalThis.peernet.put(hash, block.encoded, 'block')
     }
-    return block;
+    return block
   }
   async #resolveTransactions(transactions) {
     await Promise.all(
-      transactions.filter((hash) => Boolean(hash)).map(async (hash) => {
-        const exists = await transactionStore.has(hash);
-        if (!exists) {
-          const data = await peernet.get(hash, "transaction");
-          if (!data) throw new Error(`missing transaction data for ${hash}`);
-          await transactionStore.put(hash, data);
-        }
-        const inPool = await transactionPoolStore.has(hash);
-        if (inPool) await transactionPoolStore.delete(hash);
-      })
-    );
+      transactions
+        .filter((hash) => Boolean(hash))
+        .map(async (hash) => {
+          const exists = await transactionStore.has(hash)
+          if (!exists) {
+            const data = await peernet.get(hash, 'transaction')
+            if (!data) throw new Error(`missing transaction data for ${hash}`)
+            await transactionStore.put(hash, data)
+          }
+          const inPool = await transactionPoolStore.has(hash)
+          if (inPool) await transactionPoolStore.delete(hash)
+        })
+    )
   }
   async #resolveBlock(hash) {
-    let index = this.#blockHashMap.get(hash);
-    let localHash = "0x0";
+    let index = this.#blockHashMap.get(hash)
+    let localHash = '0x0'
     try {
-      localHash = await globalThis.stateStore.get("lastBlock");
+      localHash = await globalThis.stateStore.get('lastBlock')
     } catch (error) {
-      debug$1("no local state found");
+      debug$1('no local state found')
     }
     if (this.#blocks[index]) {
-      const previousHash = this.#blocks[index].previousHash;
-      if (previousHash === localHash) return;
-      if (previousHash !== "0x0") {
-        return this.resolveBlock(previousHash);
+      const previousHash = this.#blocks[index].previousHash
+      if (previousHash === localHash) return
+      if (previousHash !== '0x0') {
+        return this.resolveBlock(previousHash)
       } else {
-        return;
+        return
       }
     }
     try {
-      const block = await this.getAndPutBlock(hash);
-      const promises = [];
-      if (block.decoded.previousHash !== "0x0" && block.decoded.previousHash !== localHash) {
-        promises.push(this.resolveBlock(block.decoded.previousHash));
-      }
-      promises.push(this.#resolveTransactions(block.decoded.transactions));
-      await Promise.all(promises);
-      index = block.decoded.index;
-      const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
-      this.#totalSize += size;
-      this.#blocks[index] = { hash, ...block.decoded };
-      this.#blockHashMap.set(hash, index);
-      debug$1(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
-      globalThis.pubsub.publish("block-resolved", { hash, index });
-      this.#lastResolved = this.#blocks[index];
-      this.#lastResolvedTime = Date.now();
+      const block = await this.getAndPutBlock(hash)
+      const promises = []
+      if (block.decoded.previousHash !== '0x0' && block.decoded.previousHash !== localHash) {
+        promises.push(this.resolveBlock(block.decoded.previousHash))
+      }
+      promises.push(this.#resolveTransactions(block.decoded.transactions))
+      await Promise.all(promises)
+      index = block.decoded.index
+      const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength
+      this.#totalSize += size
+      this.#blocks[index] = { hash, ...block.decoded }
+      this.#blockHashMap.set(hash, index)
+      debug$1(`resolved block: ${hash} @${index} ${formatBytes(size)}`)
+      globalThis.pubsub.publish('block-resolved', { hash, index })
+      this.#lastResolved = this.#blocks[index]
+      this.#lastResolvedTime = Date.now()
     } catch (error) {
-      throw new ResolveError(`block: ${hash}@${index}`, { cause: error });
+      throw new ResolveError(`block: ${hash}@${index}`, { cause: error })
     }
-    return;
+    return
   }
   async resolveBlock(hash) {
-    if (!hash) throw new Error(`expected hash, got: ${hash}`);
-    if (hash === "0x0") return;
-    if (this.#resolvingHashes.has(hash)) return;
-    this.#resolvingHashes.add(hash);
-    const isEntering = this.#resolvingHashes.size === 1;
-    this.#resolving = true;
+    if (!hash) throw new Error(`expected hash, got: ${hash}`)
+    if (hash === '0x0') return
+    if (this.#resolvingHashes.has(hash)) return
+    this.#resolvingHashes.add(hash)
+    const isEntering = this.#resolvingHashes.size === 1
+    this.#resolving = true
     try {
       if (isEntering) {
-        if (this.jobber.busy && this.jobber.destroy) await this.jobber.destroy();
-        await this.jobber.add(() => this.#resolveBlock(hash));
+        if (this.jobber.busy && this.jobber.destroy) await this.jobber.destroy()
+        await this.jobber.add(() => this.#resolveBlock(hash))
       } else {
-        await this.#resolveBlock(hash);
+        await this.#resolveBlock(hash)
       }
       try {
-        const lastBlockHash = await globalThis.stateStore.get("lastBlock");
+        const lastBlockHash = await globalThis.stateStore.get('lastBlock')
         if (lastBlockHash === hash) {
-          this.#resolveErrored = false;
-          return;
+          this.#resolveErrored = false
+          return
         }
-      } catch (error) {
-      }
+      } catch (error) {}
     } catch (error) {
-      console.log({ error });
-      this.#resolveErrorCount += 1;
+      console.log({ error })
+      this.#resolveErrorCount += 1
       if (this.#resolveErrorCount < 3) {
-        this.#resolvingHashes.delete(hash);
-        return this.resolveBlock(hash);
+        this.#resolvingHashes.delete(hash)
+        return this.resolveBlock(hash)
       }
-      this.#resolveErrorCount = 0;
-      this.wantList.push(hash);
-      throw new ResolveError(`block: ${hash}`, { cause: error });
+      this.#resolveErrorCount = 0
+      this.wantList.push(hash)
+      throw new ResolveError(`block: ${hash}`, { cause: error })
     } finally {
-      this.#resolvingHashes.delete(hash);
-      if (this.#resolvingHashes.size === 0) this.#resolving = false;
+      this.#resolvingHashes.delete(hash)
+      if (this.#resolvingHashes.size === 0) this.#resolving = false
     }
   }
   async resolveBlocks() {
     if (this.#chainSyncing || this.#resolving) {
-      debug$1("Already syncing or resolving, skipping resolveBlocks()");
-      return;
+      debug$1('Already syncing or resolving, skipping resolveBlocks()')
+      return
     }
     try {
       if (this.jobber.busy && this.jobber.destroy) {
-        await this.jobber.destroy();
+        await this.jobber.destroy()
       }
     } catch (error) {
-      console.error(error);
+      console.error(error)
     }
     try {
-      const localBlock = await globalThis.chainStore.get("lastBlock");
-      const hash = new TextDecoder().decode(localBlock);
-      if (hash && hash !== "0x0") {
-        debug$1(`Resolving blocks from hash: ${hash}`);
-        await this.resolveBlock(hash);
+      const localBlock = await globalThis.chainStore.get('lastBlock')
+      const hash = new TextDecoder().decode(localBlock)
+      if (hash && hash !== '0x0') {
+        debug$1(`Resolving blocks from hash: ${hash}`)
+        await this.resolveBlock(hash)
       }
     } catch (error) {
-      console.log(error);
-      this.#chainSyncing = false;
-      this.#syncState = "errored";
-      this.#resolveErrored = true;
-      return this.restoreChain();
+      console.log(error)
+      this.#chainSyncing = false
+      this.#syncState = 'errored'
+      this.#resolveErrored = true
+      return this.restoreChain()
     }
   }
   async restoreChain() {
     try {
-      const { hash } = await this.#getLatestBlock();
-      await globalThis.chainStore.put("lastBlock", hash);
-      if (hash && hash !== "0x0") {
-        await this.resolveBlock(hash);
+      const { hash } = await this.#getLatestBlock()
+      await globalThis.chainStore.put('lastBlock', hash)
+      if (hash && hash !== '0x0') {
+        await this.resolveBlock(hash)
       }
     } catch (error) {
-      console.log(error);
-      this.#resolveErrored = true;
-      this.#resolveErrorCount += 1;
-      this.#resolving = false;
-      return this.restoreChain();
+      console.log(error)
+      this.#resolveErrored = true
+      this.#resolveErrorCount += 1
+      this.#resolving = false
+      return this.restoreChain()
     }
   }
   async syncChain(lastBlock) {
-    console.log("check if can sync");
-    if (!this.shouldSync) return;
-    console.log("starting sync");
-    this.#syncState = "syncing";
-    this.#chainSyncing = true;
+    console.log('check if can sync')
+    if (!this.shouldSync) return
+    console.log('starting sync')
+    this.#syncState = 'syncing'
+    this.#chainSyncing = true
     try {
       if (this.jobber.busy && this.jobber.destroy) {
-        await this.jobber.destroy();
+        await this.jobber.destroy()
       }
     } catch (error) {
-      console.error(error);
+      console.error(error)
     }
-    if (!lastBlock) lastBlock = await this.#getLatestBlock();
-    if (globalThis.peernet.peers.length === 0) return "connectionless";
+    if (!lastBlock) lastBlock = await this.#getLatestBlock()
+    if (globalThis.peernet.peers.length === 0) return 'connectionless'
     try {
-      await this.#syncChain(lastBlock);
+      await this.#syncChain(lastBlock)
     } catch (error) {
-      this.#syncErrorCount += 1;
-      if (this.#syncErrorCount < 3) return this.syncChain(lastBlock);
-      this.#syncErrorCount = 0;
-      this.#chainSyncing = false;
-      this.#syncState = "errored";
-      return this.#syncState;
-    }
-    if (lastBlock.index === this.#lastBlockInQue?.index) this.#lastBlockInQue = void 0;
-    this.#syncErrorCount = 0;
-    this.#chainSyncing = false;
-    if (this.#lastBlockInQue) return this.syncChain(this.#lastBlockInQue);
-    this.#syncState = "synced";
-    return this.#syncState;
+      this.#syncErrorCount += 1
+      if (this.#syncErrorCount < 3) return this.syncChain(lastBlock)
+      this.#syncErrorCount = 0
+      this.#chainSyncing = false
+      this.#syncState = 'errored'
+      return this.#syncState
+    }
+    if (lastBlock.index === this.#lastBlockInQue?.index) this.#lastBlockInQue = void 0
+    this.#syncErrorCount = 0
+    this.#chainSyncing = false
+    if (this.#lastBlockInQue) return this.syncChain(this.#lastBlockInQue)
+    this.#syncState = 'synced'
+    return this.#syncState
   }
   async #syncChain(lastBlock) {
     try {
-      const localBlock = await this.lastBlock;
-      const localIndex = localBlock ? Number(localBlock.index) : -1;
-      const remoteIndex = Number(lastBlock.index);
-      const remoteBlockHash = lastBlock.hash;
-      let localStateHash = "0x0";
+      const localBlock = await this.lastBlock
+      const localIndex = localBlock ? Number(localBlock.index) : -1
+      const remoteIndex = Number(lastBlock.index)
+      const remoteBlockHash = lastBlock.hash
+      let localStateHash = '0x0'
       try {
-        localStateHash = new TextDecoder().decode(await globalThis.chainStore.get("lastBlock"));
+        localStateHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'))
       } catch (error) {
-        debug$1(`No local state hash found: ${error}`);
+        debug$1(`No local state hash found: ${error}`)
       }
-      debug$1(`Local block height: ${localIndex}, remote block height: ${remoteIndex}`);
-      debug$1(`Local state hash: ${localStateHash}, remote block hash: ${remoteBlockHash}`);
-      if (remoteBlockHash === "0x0") {
-        debug$1(`Remote block hash is 0x0, skipping sync`);
-        return;
+      debug$1(`Local block height: ${localIndex}, remote block height: ${remoteIndex}`)
+      debug$1(`Local state hash: ${localStateHash}, remote block hash: ${remoteBlockHash}`)
+      if (remoteBlockHash === '0x0') {
+        debug$1(`Remote block hash is 0x0, skipping sync`)
+        return
       }
       if (localIndex > remoteIndex) {
-        debug$1(`Local index ${localIndex} is ahead of remote ${remoteIndex}, skipping sync`);
-        return;
+        debug$1(`Local index ${localIndex} is ahead of remote ${remoteIndex}, skipping sync`)
+        return
       }
-      const MAX_REORG_DEPTH = 6;
-      const reorgDepth = localIndex - remoteIndex;
+      const MAX_REORG_DEPTH = 6
+      const reorgDepth = localIndex - remoteIndex
       if (reorgDepth > 0 && reorgDepth > MAX_REORG_DEPTH) {
         console.warn(
           `[consensus-safety] Peer proposing reorg depth of ${reorgDepth} blocks (limit is ${MAX_REORG_DEPTH}). Rejecting to prevent DoS.`
-        );
-        throw new Error(`Excessive reorg depth: ${reorgDepth} blocks (max ${MAX_REORG_DEPTH})`);
+        )
+        throw new Error(`Excessive reorg depth: ${reorgDepth} blocks (max ${MAX_REORG_DEPTH})`)
       }
       if (localStateHash !== remoteBlockHash) {
         if (this.wantList.length > 0) {
-          debug$1(`Fetching ${this.wantList.length} blocks before resolving`);
+          debug$1(`Fetching ${this.wantList.length} blocks before resolving`)
           const getBatch = async (batch) => {
             const blocks2 = await Promise.all(
-              batch.map(
-                (hash) => this.getAndPutBlock(hash).catch((e) => {
-                  console.warn(`failed to fetch block ${hash}`, e);
+              batch.map((hash) =>
+                this.getAndPutBlock(hash).catch((e) => {
+                  console.warn(`failed to fetch block ${hash}`, e)
                 })
               )
-            );
-            const transactions = blocks2.filter((block) => Boolean(block)).flatMap((block) => block.decoded.transactions);
-            return this.#resolveTransactions(transactions);
-          };
+            )
+            const transactions = blocks2
+              .filter((block) => Boolean(block))
+              .flatMap((block) => block.decoded.transactions)
+            return this.#resolveTransactions(transactions)
+          }
           for (let i = 0; i < this.wantList.length; i += 50) {
-            const batch = this.wantList.slice(i, i + 50);
-            await getBatch(batch);
+            const batch = this.wantList.slice(i, i + 50)
+            await getBatch(batch)
           }
         }
-        debug$1(`Resolving remote block: ${remoteBlockHash} @${remoteIndex} (differs from local state)`);
-        await this.resolveBlock(remoteBlockHash);
-        const blocksSynced = remoteIndex - localIndex;
-        debug$1(`Resolved ${blocksSynced} new block(s)`);
-        const blocks = this.#blocks;
-        debug$1(`Loading blocks from index ${localIndex + 1} to ${remoteIndex}`);
-        const start = localIndex + 1;
+        debug$1(`Resolving remote block: ${remoteBlockHash} @${remoteIndex} (differs from local state)`)
+        await this.resolveBlock(remoteBlockHash)
+        const blocksSynced = remoteIndex - localIndex
+        debug$1(`Resolved ${blocksSynced} new block(s)`)
+        const blocks = this.#blocks
+        debug$1(`Loading blocks from index ${localIndex + 1} to ${remoteIndex}`)
+        const start = localIndex + 1
         if (this.#machine && blocks.length > start) {
-          await this.#loadBlocks(blocks.slice(start));
+          await this.#loadBlocks(blocks.slice(start))
         }
         if (blocks.length > 0) {
-          await this.updateState(new BlockMessage(blocks[blocks.length - 1]));
+          await this.updateState(new BlockMessage(blocks[blocks.length - 1]))
         }
       } else {
-        debug$1(`Block already in local state. Remote hash: ${remoteBlockHash} matches local state`);
+        debug$1(`Block already in local state. Remote hash: ${remoteBlockHash} matches local state`)
       }
     } catch (error) {
-      console.log(error);
-      throw error;
+      console.log(error)
+      throw error
     }
   }
   async #getLatestBlock() {
-    let promises = [];
-    const connectedPeers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected);
-    let compatiblePeerCount = 0;
-    let data = await new globalThis.peernet.protos["peernet-request"]({
-      request: "lastBlock"
-    });
-    let node = await globalThis.peernet.prepareMessage(data);
+    let promises = []
+    const connectedPeers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected)
+    let compatiblePeerCount = 0
+    let data = await new globalThis.peernet.protos['peernet-request']({
+      request: 'lastBlock'
+    })
+    let node = await globalThis.peernet.prepareMessage(data)
     for (const id in globalThis.peernet.connections) {
-      const peer = globalThis.peernet.connections[id];
+      const peer = globalThis.peernet.connections[id]
       if (peer.connected && this.isVersionCompatible(peer.version)) {
-        compatiblePeerCount += 1;
+        compatiblePeerCount += 1
         const task = async () => {
           try {
-            const result = await peer.request(node.encoded);
-            const resultType = result instanceof Uint8Array ? `bytes:${result.length}` : typeof result;
-            debug$1(`lastBlock result type: ${resultType}`);
-            console.log({ result });
-            return { result: new LastBlockMessage(result), peer };
+            const result = await peer.request(node.encoded)
+            const resultType = result instanceof Uint8Array ? `bytes:${result.length}` : typeof result
+            debug$1(`lastBlock result type: ${resultType}`)
+            console.log({ result })
+            return { result: new LastBlockMessage(result), peer }
           } catch (error) {
-            const peerId = peer?.peerId || peer?.id || peer?.address || "unknown";
-            debug$1(`lastBlock request failed: ${peerId}:`, error?.message ?? error);
-            throw error;
+            const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown'
+            debug$1(`lastBlock request failed: ${peerId}:`, error?.message ?? error)
+            throw error
           }
-        };
-        promises.push(task());
+        }
+        promises.push(task())
       }
     }
     if (connectedPeers.length > 0 && compatiblePeerCount === 0) {
       throw new ResolveError(
         `latestBlock: no compatible peers found for local version ${this.version} among ${connectedPeers.length} connected peers`
-      );
+      )
     }
-    console.log({ promises });
-    promises = await this.promiseRequests(promises);
+    console.log({ promises })
+    promises = await this.promiseRequests(promises)
     if (compatiblePeerCount > 0 && promises.length === 0) {
-      throw new ResolveError("latestBlock: no responses from compatible peers");
-    }
-    console.log({ promises });
-    let latest = { index: 0, hash: "0x0", previousHash: "0x0" };
-    promises = promises.sort((a, b) => b.index - a.index);
-    if (promises.length > 0) latest = promises[0].value;
-    debug$1(`Latest block from peers: ${latest.hash} @${latest.index}`);
-    if (latest.hash && latest.hash !== "0x0") {
-      let message = await globalThis.peernet.get(latest.hash, "block");
-      message = await new BlockMessage(message);
-      const hash = await message.hash();
-      if (hash !== latest.hash) throw new Error("invalid block @getLatestBlock");
-      latest = { ...message.decoded, hash };
-      const peer = promises[0].peer;
+      throw new ResolveError('latestBlock: no responses from compatible peers')
+    }
+    console.log({ promises })
+    let latest = { index: 0, hash: '0x0', previousHash: '0x0' }
+    promises = promises.sort((a, b) => b.index - a.index)
+    if (promises.length > 0) latest = promises[0].value
+    debug$1(`Latest block from peers: ${latest.hash} @${latest.index}`)
+    if (latest.hash && latest.hash !== '0x0') {
+      let message = await globalThis.peernet.get(latest.hash, 'block')
+      message = await new BlockMessage(message)
+      const hash = await message.hash()
+      if (hash !== latest.hash) throw new Error('invalid block @getLatestBlock')
+      latest = { ...message.decoded, hash }
+      const peer = promises[0].peer
       if (peer.connected && this.isVersionCompatible(peer.version)) {
-        let data2 = await new globalThis.peernet.protos["peernet-request"]({
-          request: "knownBlocks"
-        });
-        let node2 = await globalThis.peernet.prepareMessage(data2);
+        let data2 = await new globalThis.peernet.protos['peernet-request']({
+          request: 'knownBlocks'
+        })
+        let node2 = await globalThis.peernet.prepareMessage(data2)
         try {
-          let message2 = await peer.request(node2.encode());
-          message2 = await new globalThis.peernet.protos["peernet-response"](message2);
-          const MAX_WANTLIST_SIZE = 1e3;
-          const incoming = message2.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block));
-          const remaining = MAX_WANTLIST_SIZE - this.wantList.length;
-          if (remaining > 0) this.wantList.push(...incoming.slice(0, remaining));
+          let message2 = await peer.request(node2.encode())
+          message2 = await new globalThis.peernet.protos['peernet-response'](message2)
+          const MAX_WANTLIST_SIZE = 1e3
+          const incoming = message2.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block))
+          const remaining = MAX_WANTLIST_SIZE - this.wantList.length
+          if (remaining > 0) this.wantList.push(...incoming.slice(0, remaining))
         } catch (error) {
-          const peerId = peer?.peerId || peer?.id || peer?.address || "unknown";
-          debug$1(`knownBlocks request failed: ${peerId}:`, error?.message ?? error);
-          throw error;
+          const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown'
+          debug$1(`knownBlocks request failed: ${peerId}:`, error?.message ?? error)
+          throw error
         }
       }
     }
-    return latest;
+    return latest
   }
-  #loadBlockTransactions;
-  #getLastTransactions;
+  #loadBlockTransactions
+  #getLastTransactions
   // todo throw error
   async #_executeTransaction(transaction) {
     try {
-      await this.#machine.execute(transaction.decoded.to, transaction.decoded.method, transaction.decoded.params);
+      await this.#machine.execute(transaction.decoded.to, transaction.decoded.method, transaction.decoded.params)
     } catch (error) {
-      console.log(error);
-      await globalThis.transactionPoolStore.delete(await transaction.hash());
-      console.log("removing invalid transaction");
+      console.log(error)
+      await globalThis.transactionPoolStore.delete(await transaction.hash())
+      console.log('removing invalid transaction')
       if (isExecutionError(error)) {
-        console.log(error);
+        console.log(error)
       }
-      console.log(error);
-      return false;
+      console.log(error)
+      return false
     }
   }
   /**
@@ -1652,515 +1693,518 @@ class State extends Contract {
    * @param {Block[]} blocks
    */
   async #loadBlocks(blocks) {
-    this.#chainState = "loading";
-    const poolTransactionKeys = new Set(await globalThis.transactionPoolStore.keys());
-    debug$1(`pool transactions: ${poolTransactionKeys.size}`);
-    debug$1(`loading ${blocks.length} blocks`);
+    this.#chainState = 'loading'
+    const poolTransactionKeys = new Set(await globalThis.transactionPoolStore.keys())
+    debug$1(`pool transactions: ${poolTransactionKeys.size}`)
+    debug$1(`loading ${blocks.length} blocks`)
     for (const block of blocks) {
       if (block && !block.loaded) {
         try {
-          debug$1(`loading block: ${Number(block.index)} ${block.hash}`);
-          let transactions = await this.#loadBlockTransactions(block.transactions || []);
-          debug$1(`loading transactions: ${transactions.length} for block ${block.index}`);
-          let priority = [];
+          debug$1(`loading block: ${Number(block.index)} ${block.hash}`)
+          let transactions = await this.#loadBlockTransactions(block.transactions || [])
+          debug$1(`loading transactions: ${transactions.length} for block ${block.index}`)
+          let priority = []
           for (const transaction of transactions) {
-            const hash = await transaction.hash();
-            if (transaction.decoded.priority) priority.push(transaction);
-            if (poolTransactionKeys.has(hash)) await globalThis.transactionPoolStore.delete(hash);
+            const hash = await transaction.hash()
+            if (transaction.decoded.priority) priority.push(transaction)
+            if (poolTransactionKeys.has(hash)) await globalThis.transactionPoolStore.delete(hash)
           }
           if (priority.length > 0) {
-            debug$1(`executing ${priority.length} priority transactions for block ${block.index}`);
-            priority = priority.sort((a, b) => a.nonce - b.nonce);
+            debug$1(`executing ${priority.length} priority transactions for block ${block.index}`)
+            priority = priority.sort((a, b) => a.nonce - b.nonce)
             for (const transaction of priority) {
-              await this.#_executeTransaction(transaction);
+              await this.#_executeTransaction(transaction)
             }
           }
-          transactions = transactions.filter((transaction) => !transaction.decoded.priority);
-          debug$1(`executing ${transactions.length} transactions for block ${block.index}`);
-          await Promise.all(transactions.map((transaction) => this.#_executeTransaction(transaction)));
-          this.#blocks[block.index].loaded = true;
-          debug$1(`executed transactions for block ${block.index}`);
-          if (Number(block.index) === 0) this.#loaded = true;
-          await this.#machine.addLoadedBlock(block);
-          debug$1(`loaded block: ${block.hash} @${Number(block.index)}`);
-          globalThis.pubsub.publish("block-loaded", { ...block });
+          transactions = transactions.filter((transaction) => !transaction.decoded.priority)
+          debug$1(`executing ${transactions.length} transactions for block ${block.index}`)
+          await Promise.all(transactions.map((transaction) => this.#_executeTransaction(transaction)))
+          this.#blocks[block.index].loaded = true
+          debug$1(`executed transactions for block ${block.index}`)
+          if (Number(block.index) === 0) this.#loaded = true
+          await this.#machine.addLoadedBlock(block)
+          debug$1(`loaded block: ${block.hash} @${Number(block.index)}`)
+          globalThis.pubsub.publish('block-loaded', { ...block })
         } catch (error) {
-          console.error(error);
+          console.error(error)
           for (const transaction of block.transactions) {
-            this.wantList.push(transaction);
+            this.wantList.push(transaction)
           }
         }
       }
     }
-    this.#chainState = "loaded";
-    return true;
+    this.#chainState = 'loaded'
+    return true
   }
   promiseRequests(promises) {
     return new Promise(async (resolve, reject) => {
       const timeout = setTimeout(() => {
-        resolve([{ index: 0, hash: "0x0" }]);
-        debug$1("sync timed out");
-      }, this.requestTimeout);
-      console.log({ promises });
-      promises = await Promise.allSettled(promises);
-      console.log({ promises });
-      promises = promises.filter(({ status }) => status === "fulfilled");
-      clearTimeout(timeout);
+        resolve([{ index: 0, hash: '0x0' }])
+        debug$1('sync timed out')
+      }, this.requestTimeout)
+      console.log({ promises })
+      promises = await Promise.allSettled(promises)
+      console.log({ promises })
+      promises = promises.filter(({ status }) => status === 'fulfilled')
+      clearTimeout(timeout)
       if (promises.length > 0) {
         promises = promises.map(async ({ value }) => {
-          const node = await new globalThis.peernet.protos["peernet-response"](value.result);
-          return { value: node.decoded.response, peer: value.peer };
-        });
-        promises = await Promise.all(promises);
-        resolve(promises);
+          const node = await new globalThis.peernet.protos['peernet-response'](value.result)
+          return { value: node.decoded.response, peer: value.peer }
+        })
+        promises = await Promise.all(promises)
+        resolve(promises)
       } else {
-        resolve([]);
+        resolve([])
       }
-    });
+    })
   }
   get canSync() {
-    if (this.#chainSyncing) return false;
-    return true;
+    if (this.#chainSyncing) return false
+    return true
   }
   get shouldSync() {
-    if (this.#chainSyncing) return false;
+    if (this.#chainSyncing) return false
     const compatiblePeers = Object.values(globalThis.peernet.connections || {}).filter(
       (peer) => peer.connected && this.isVersionCompatible(peer.version)
-    );
+    )
     if (compatiblePeers.length === 0) {
-      debug$1("No compatible peers available for sync");
-      return false;
-    }
-    if (!this.#chainSyncing || this.#resolveErrored || this.#syncState === "errored" || this.#syncState === "connectionless" || this.#lastResolvedTime + this.resolveTimeout > Date.now())
-      return true;
-    return false;
+      debug$1('No compatible peers available for sync')
+      return false
+    }
+    if (
+      !this.#chainSyncing ||
+      this.#resolveErrored ||
+      this.#syncState === 'errored' ||
+      this.#syncState === 'connectionless' ||
+      this.#lastResolvedTime + this.resolveTimeout > Date.now()
+    )
+      return true
+    return false
   }
   async #waitForPeers(timeoutMs = 3e4) {
     return new Promise((resolve) => {
       const checkPeers = () => {
         const peers = Object.values(globalThis.peernet.connections || {}).filter(
           (peer) => peer.connected && this.isVersionCompatible(peer.version)
-        );
+        )
         if (peers.length > 0) {
-          resolve(true);
+          resolve(true)
         }
-      };
-      checkPeers();
-      const interval = setInterval(checkPeers, 1e3);
+      }
+      checkPeers()
+      const interval = setInterval(checkPeers, 1e3)
       setTimeout(() => {
-        clearInterval(interval);
-        resolve(false);
-      }, timeoutMs);
-    });
+        clearInterval(interval)
+        resolve(false)
+      }, timeoutMs)
+    })
   }
   async triggerSync() {
-    const latest = await this.#getLatestBlock();
-    return this.syncChain(latest);
+    const latest = await this.#getLatestBlock()
+    return this.syncChain(latest)
   }
   async triggerLoad() {
     if (this.#blocks?.length > 0) {
-      const machine = new Machine(this.#blocks);
-      console.log(machine);
-      await machine.ready;
-      this.#machine = machine;
+      const machine = new Machine(this.#blocks)
+      console.log(machine)
+      await machine.ready
+      this.#machine = machine
     }
   }
 }
 
 class VersionControl extends State {
   constructor(config) {
-    super(config);
+    super(config)
   }
-  #currentVersion = PROTOCOL_VERSION;
-  #reachedOneZeroZero = REACHED_ONE_ZERO_ZERO;
+  #currentVersion = PROTOCOL_VERSION
+  #reachedOneZeroZero = REACHED_ONE_ZERO_ZERO
   async #setCurrentVersion() {
-    this.version = this.#currentVersion;
-    await globalThis.chainStore.put("version", this.version);
+    this.version = this.#currentVersion
+    await globalThis.chainStore.put('version', this.version)
   }
   async init() {
-    super.init && await super.init();
+    super.init && (await super.init())
     try {
-      const version = await globalThis.chainStore.get("version");
-      const storedVersion = new TextDecoder().decode(version);
-      console.log(storedVersion, this.#currentVersion);
-      this.version = this.#currentVersion;
-      console.warn("the reachedZeroZero flag is set to false, this will clear all data on every start if above v1.0.0");
-      if (semver.compare(storedVersion, "1.0.0") === 1 && !this.#reachedOneZeroZero) {
-        console.warn("clearing all data because we are below v1.0.0");
-        await this.clearAll();
+      const version = await globalThis.chainStore.get('version')
+      const storedVersion = new TextDecoder().decode(version)
+      console.log(storedVersion, this.#currentVersion)
+      this.version = this.#currentVersion
+      console.warn('the reachedZeroZero flag is set to false, this will clear all data on every start if above v1.0.0')
+      if (semver.compare(storedVersion, '1.0.0') === 1 && !this.#reachedOneZeroZero) {
+        console.warn('clearing all data because we are below v1.0.0')
+        await this.clearAll()
       }
       if (storedVersion !== this.#currentVersion) {
-        console.log(`Version mismatch: stored=${storedVersion}, current=${this.#currentVersion}. Updating...`);
-        await globalThis.chainStore.put("version", this.version);
+        console.log(`Version mismatch: stored=${storedVersion}, current=${this.#currentVersion}. Updating...`)
+        await globalThis.chainStore.put('version', this.version)
       }
     } catch (e) {
-      console.log(e);
-      return this.#setCurrentVersion();
+      console.log(e)
+      return this.#setCurrentVersion()
     }
   }
   isVersionCompatible(peerVersion) {
-    if (!peerVersion || !this.version) return false;
-    const [peerMajor, peerMinor] = peerVersion.split(".");
-    const [localMajor, localMinor] = this.version.split(".");
-    return peerMajor === localMajor && peerMinor === localMinor;
+    if (!peerVersion || !this.version) return false
+    const [peerMajor, peerMinor] = peerVersion.split('.')
+    const [localMajor, localMinor] = this.version.split('.')
+    return peerMajor === localMajor && peerMinor === localMinor
   }
 }
 
 class ConnectionMonitor {
-  #isMonitoring = false;
-  #checkInterval = null;
-  #reconnectDelay = 5e3;
-  #reconnectTimer = null;
-  #healthCheckInterval = 6e4;
-  #version;
-  #lastHealthCheckAt = 0;
-  #reconnecting = false;
+  #isMonitoring = false
+  #checkInterval = null
+  #reconnectDelay = 5e3
+  #reconnectTimer = null
+  #healthCheckInterval = 6e4
+  #version
+  #lastHealthCheckAt = 0
+  #reconnecting = false
   // event handlers to remove later
-  #onOnline = null;
-  #onVisibilityChange = null;
-  #onSigcont = null;
-  #onPeerConnected = null;
+  #onOnline = null
+  #onVisibilityChange = null
+  #onSigcont = null
+  #onPeerConnected = null
   get isMonitoring() {
-    return this.#isMonitoring;
+    return this.#isMonitoring
   }
   get connectedPeers() {
-    return Object.values(globalThis.peernet?.connections || {}).filter((peer) => peer.connected);
+    return Object.values(globalThis.peernet?.connections || {}).filter((peer) => peer.connected)
   }
   get compatiblePeers() {
     return this.connectedPeers.filter((peer) => {
-      if (!peer.version || !this.#version) return false;
-      const [peerMajor, peerMinor] = peer.version.split(".");
-      const [localMajor, localMinor] = this.#version.split(".");
-      return peerMajor === localMajor && peerMinor === localMinor;
-    });
+      if (!peer.version || !this.#version) return false
+      const [peerMajor, peerMinor] = peer.version.split('.')
+      const [localMajor, localMinor] = this.#version.split('.')
+      return peerMajor === localMajor && peerMinor === localMinor
+    })
   }
   get disconnectedPeers() {
-    return Object.values(globalThis.peernet?.connections || {}).filter((peer) => !peer.connected);
+    return Object.values(globalThis.peernet?.connections || {}).filter((peer) => !peer.connected)
   }
   start(version) {
-    this.#version = version;
-    console.log(`\u{1F517} Connection Monitor initialized for version: ${this.#version}`);
-    if (this.#isMonitoring) return;
-    this.#isMonitoring = true;
-    console.log("\u{1F504} Starting connection monitor...");
-    if (typeof window !== "undefined" && typeof document !== "undefined") {
+    this.#version = version
+    console.log(`\u{1F517} Connection Monitor initialized for version: ${this.#version}`)
+    if (this.#isMonitoring) return
+    this.#isMonitoring = true
+    console.log('\u{1F504} Starting connection monitor...')
+    if (typeof window !== 'undefined' && typeof document !== 'undefined') {
       this.#onOnline = () => {
-        console.log("\u{1F310} Network online \u2014 attempting restore");
-        void this.#restoreNetwork();
-      };
-      window.addEventListener("online", this.#onOnline);
+        console.log('\u{1F310} Network online \u2014 attempting restore')
+        void this.#restoreNetwork()
+      }
+      window.addEventListener('online', this.#onOnline)
       this.#onVisibilityChange = () => {
-        if (document.visibilityState === "visible") {
-          console.log("\u{1F4A1} Visibility regained");
+        if (document.visibilityState === 'visible') {
+          console.log('\u{1F4A1} Visibility regained')
           if (this.connectedPeers.length === 0) {
-            console.log("\u{1F4A1} Visibility regained \u2014 attempting restore");
-            void this.#restoreNetwork();
+            console.log('\u{1F4A1} Visibility regained \u2014 attempting restore')
+            void this.#restoreNetwork()
           }
         }
-      };
-      document.addEventListener("visibilitychange", this.#onVisibilityChange);
+      }
+      document.addEventListener('visibilitychange', this.#onVisibilityChange)
     }
-    if (typeof process !== "undefined" && typeof process.on === "function") {
+    if (typeof process !== 'undefined' && typeof process.on === 'function') {
       this.#onSigcont = () => {
-        console.log("\u{1F514} Process resumed (SIGCONT) \u2014 attempting restore");
-        void this.#restoreNetwork();
-      };
-      try {
-        process.on("SIGCONT", this.#onSigcont);
-      } catch (e) {
+        console.log('\u{1F514} Process resumed (SIGCONT) \u2014 attempting restore')
+        void this.#restoreNetwork()
       }
+      try {
+        process.on('SIGCONT', this.#onSigcont)
+      } catch (e) {}
     }
-    this.#lastHealthCheckAt = Date.now();
+    this.#lastHealthCheckAt = Date.now()
     this.#checkInterval = setInterval(() => {
-      this.#healthCheck();
-    }, this.#healthCheckInterval);
+      this.#healthCheck()
+    }, this.#healthCheckInterval)
     this.#onPeerConnected = () => {
       if (this.#reconnectTimer) {
-        clearTimeout(this.#reconnectTimer);
-        this.#reconnectTimer = null;
+        clearTimeout(this.#reconnectTimer)
+        this.#reconnectTimer = null
       }
-      this.#reconnecting = false;
-      this.#reconnectDelay = 5e3;
-    };
-    globalThis.pubsub?.subscribe("peer:connected", this.#onPeerConnected);
+      this.#reconnecting = false
+      this.#reconnectDelay = 5e3
+    }
+    globalThis.pubsub?.subscribe('peer:connected', this.#onPeerConnected)
   }
   stop() {
-    if (!this.#isMonitoring) return;
-    this.#isMonitoring = false;
+    if (!this.#isMonitoring) return
+    this.#isMonitoring = false
     if (this.#checkInterval) {
-      clearInterval(this.#checkInterval);
-      this.#checkInterval = null;
+      clearInterval(this.#checkInterval)
+      this.#checkInterval = null
     }
-    if (typeof window !== "undefined") {
+    if (typeof window !== 'undefined') {
       if (this.#onOnline) {
-        window.removeEventListener("online", this.#onOnline);
-        this.#onOnline = null;
+        window.removeEventListener('online', this.#onOnline)
+        this.#onOnline = null
       }
       if (this.#onVisibilityChange) {
-        document.removeEventListener("visibilitychange", this.#onVisibilityChange);
-        this.#onVisibilityChange = null;
+        document.removeEventListener('visibilitychange', this.#onVisibilityChange)
+        this.#onVisibilityChange = null
       }
     }
-    if (typeof process !== "undefined" && typeof process.removeListener === "function" && this.#onSigcont) {
+    if (typeof process !== 'undefined' && typeof process.removeListener === 'function' && this.#onSigcont) {
       try {
-        process.removeListener("SIGCONT", this.#onSigcont);
-      } catch (e) {
-      }
-      this.#onSigcont = null;
+        process.removeListener('SIGCONT', this.#onSigcont)
+      } catch (e) {}
+      this.#onSigcont = null
     }
     if (this.#onPeerConnected) {
-      globalThis.pubsub?.unsubscribe("peer:connected", this.#onPeerConnected);
-      this.#onPeerConnected = null;
+      globalThis.pubsub?.unsubscribe('peer:connected', this.#onPeerConnected)
+      this.#onPeerConnected = null
     }
     if (this.#reconnectTimer) {
-      clearTimeout(this.#reconnectTimer);
-      this.#reconnectTimer = null;
+      clearTimeout(this.#reconnectTimer)
+      this.#reconnectTimer = null
     }
-    console.log("\u23F9\uFE0F Connection monitor stopped");
+    console.log('\u23F9\uFE0F Connection monitor stopped')
   }
   async #healthCheck() {
-    const now = Date.now();
-    const expectedNext = this.#lastHealthCheckAt + this.#healthCheckInterval;
-    const drift = now - expectedNext;
-    this.#lastHealthCheckAt = now;
+    const now = Date.now()
+    const expectedNext = this.#lastHealthCheckAt + this.#healthCheckInterval
+    const drift = now - expectedNext
+    this.#lastHealthCheckAt = now
     if (drift > 5e3) {
-      console.log(`\u23F0 Detected timer drift of ${drift}ms (likely system sleep) \u2014 attempting restore`);
-      void this.#restoreNetwork();
+      console.log(`\u23F0 Detected timer drift of ${drift}ms (likely system sleep) \u2014 attempting restore`)
+      void this.#restoreNetwork()
     }
-    const connectedPeers = this.connectedPeers;
-    const compatiblePeers = this.compatiblePeers;
-    const disconnectedPeers = this.disconnectedPeers;
+    const connectedPeers = this.connectedPeers
+    const compatiblePeers = this.compatiblePeers
+    const disconnectedPeers = this.disconnectedPeers
     console.log(
       `\u{1F50D} Health check: ${connectedPeers.length} connected, ${compatiblePeers.length} compatible, ${disconnectedPeers.length} negotiating`
-    );
+    )
     if (connectedPeers.length === 0 && disconnectedPeers.length === 0) {
-      console.warn("\u26A0\uFE0F No peer connections detected \u2014 attempting reconnection");
-      await this.#attemptReconnection();
+      console.warn('\u26A0\uFE0F No peer connections detected \u2014 attempting reconnection')
+      await this.#attemptReconnection()
     } else if (compatiblePeers.length === 0 && connectedPeers.length > 0) {
-      console.warn("\u26A0\uFE0F No compatible peers found \u2014 attempting reconnection");
-      await this.#attemptReconnection();
+      console.warn('\u26A0\uFE0F No compatible peers found \u2014 attempting reconnection')
+      await this.#attemptReconnection()
     }
-    globalThis.pubsub?.publish("connection-status", {
+    globalThis.pubsub?.publish('connection-status', {
       connected: connectedPeers.length,
       compatible: compatiblePeers.length,
       healthy: compatiblePeers.length > 0
-    });
+    })
   }
   // lightweight TCP probe to detect internet connectivity in Node.js
   async #isOnLine(timeout = 1500) {
     if (navigator?.onLine !== void 0) {
-      return navigator.onLine;
+      return navigator.onLine
     }
     return new Promise(async (resolve) => {
       try {
-        const net = await import('net');
-        const socket = new net.Socket();
-        let finished = false;
+        const net = await import('net')
+        const socket = new net.Socket()
+        let finished = false
         const finish = (val) => {
-          if (finished) return;
-          finished = true;
+          if (finished) return
+          finished = true
           try {
-            socket.destroy();
-          } catch (e) {
-          }
-          resolve(val);
-        };
-        socket.setTimeout(timeout);
-        socket.once("connect", () => finish(true));
-        socket.once("error", () => finish(false));
-        socket.once("timeout", () => finish(false));
-        socket.connect(53, "1.1.1.1");
+            socket.destroy()
+          } catch (e) {}
+          resolve(val)
+        }
+        socket.setTimeout(timeout)
+        socket.once('connect', () => finish(true))
+        socket.once('error', () => finish(false))
+        socket.once('timeout', () => finish(false))
+        socket.connect(53, '1.1.1.1')
       } catch (e) {
-        resolve(false);
+        resolve(false)
       }
-    });
+    })
   }
   // Called on visibility/online/resume events
   async #restoreNetwork() {
     if (this.#reconnecting) {
-      console.log("\u{1F501} Reconnection already in progress, skipping");
-      return;
+      console.log('\u{1F501} Reconnection already in progress, skipping')
+      return
     }
-    this.#reconnecting = true;
+    this.#reconnecting = true
     if (this.connectedPeers.length > 0) {
-      console.log("\u2705 Already connected to peers, skipping restoration");
-      this.#reconnecting = false;
-      return;
+      console.log('\u2705 Already connected to peers, skipping restoration')
+      this.#reconnecting = false
+      return
     }
-    console.log("\u{1F501} Restoring network");
+    console.log('\u{1F501} Restoring network')
     try {
-      const online = await this.#isOnLine(1500);
+      const online = await this.#isOnLine(1500)
       if (!online) {
-        console.warn("\u26A0\uFE0F No internet detected, skipping restore");
-        this.#reconnecting = false;
-        return;
+        console.warn('\u26A0\uFE0F No internet detected, skipping restore')
+        this.#reconnecting = false
+        return
       }
     } catch (e) {
-      console.warn("\u26A0\uFE0F Online probe failed, proceeding with restore", e?.message || e);
+      console.warn('\u26A0\uFE0F Online probe failed, proceeding with restore', e?.message || e)
     }
     try {
-      console.log("\u{1F504} Attempting network restoration...");
+      console.log('\u{1F504} Attempting network restoration...')
       if (globalThis.peernet?.client?.reinit) {
-        console.log("  \u2192 Trying client.reinit()");
+        console.log('  \u2192 Trying client.reinit()')
         try {
-          await globalThis.peernet.client.reinit();
-          console.log("  \u2705 client.reinit() succeeded");
+          await globalThis.peernet.client.reinit()
+          console.log('  \u2705 client.reinit() succeeded')
         } catch (e) {
-          console.warn("  \u26A0\uFE0F client.reinit() failed:", e?.message || e);
+          console.warn('  \u26A0\uFE0F client.reinit() failed:', e?.message || e)
         }
       }
       if (globalThis.peernet?.start) {
-        console.log("  \u2192 Trying peernet.start()");
+        console.log('  \u2192 Trying peernet.start()')
         try {
-          await globalThis.peernet.start();
-          console.log("  \u2705 peernet.start() succeeded");
+          await globalThis.peernet.start()
+          console.log('  \u2705 peernet.start() succeeded')
         } catch (e) {
-          console.warn("  \u26A0\uFE0F peernet.start() failed:", e?.message || e);
+          console.warn('  \u26A0\uFE0F peernet.start() failed:', e?.message || e)
         }
       }
       try {
-        const networkName = globalThis.peernet?.network;
-        if (networkName && typeof networkName === "string") {
-          const { default: networks } = await import('@leofcoin/networks');
-          const [mainKey, subKey] = networkName.split(":");
-          const networkConfig = networks?.[mainKey]?.[subKey];
+        const networkName = globalThis.peernet?.network
+        if (networkName && typeof networkName === 'string') {
+          const { default: networks } = await import('@leofcoin/networks')
+          const [mainKey, subKey] = networkName.split(':')
+          const networkConfig = networks?.[mainKey]?.[subKey]
           if (networkConfig?.stars && Array.isArray(networkConfig.stars)) {
-            console.log("  \u2192 Attempting to dial star servers:", networkConfig.stars.join(", "));
+            console.log('  \u2192 Attempting to dial star servers:', networkConfig.stars.join(', '))
             for (const star of networkConfig.stars) {
               try {
-                if (globalThis.peernet?.client && "dial" in globalThis.peernet.client) {
-                  await globalThis.peernet.client.dial(star);
-                  console.log(`  \u2705 Connected to star server: ${star}`);
+                if (globalThis.peernet?.client && 'dial' in globalThis.peernet.client) {
+                  await globalThis.peernet.client.dial(star)
+                  console.log(`  \u2705 Connected to star server: ${star}`)
                 }
               } catch (e) {
-                console.warn(`  \u26A0\uFE0F Failed to dial ${star}:`, e?.message || e);
+                console.warn(`  \u26A0\uFE0F Failed to dial ${star}:`, e?.message || e)
               }
             }
           }
         }
       } catch (e) {
-        console.warn("  \u26A0\uFE0F Could not load or dial star servers:", e?.message || e);
+        console.warn('  \u26A0\uFE0F Could not load or dial star servers:', e?.message || e)
       }
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
-      const connectedAfter = this.connectedPeers.length;
-      console.log(`\u{1F504} Restoration complete. Connected peers: ${connectedAfter}`);
+      await new Promise((resolve) => setTimeout(resolve, 2e3))
+      const connectedAfter = this.connectedPeers.length
+      console.log(`\u{1F504} Restoration complete. Connected peers: ${connectedAfter}`)
     } catch (error) {
-      console.error("\u274C Network restoration failed:", error?.message || error);
+      console.error('\u274C Network restoration failed:', error?.message || error)
     } finally {
-      this.#reconnecting = false;
+      this.#reconnecting = false
     }
   }
   async waitForPeers(timeoutMs = 3e4) {
     return new Promise((resolve) => {
-      const startTime = Date.now();
+      const startTime = Date.now()
       const checkPeers = () => {
         if (this.compatiblePeers.length > 0) {
-          resolve(true);
-          return;
+          resolve(true)
+          return
         }
         if (Date.now() - startTime >= timeoutMs) {
-          resolve(false);
-          return;
+          resolve(false)
+          return
         }
-        setTimeout(checkPeers, 1e3);
-      };
-      checkPeers();
-    });
+        setTimeout(checkPeers, 1e3)
+      }
+      checkPeers()
+    })
   }
   async #attemptReconnection() {
     try {
-      await this.#restoreNetwork();
-      const hasConnections = this.connectedPeers.length > 0 || this.disconnectedPeers.length > 0;
+      await this.#restoreNetwork()
+      const hasConnections = this.connectedPeers.length > 0 || this.disconnectedPeers.length > 0
       if (hasConnections) {
-        console.log("\u2705 Reconnection successful, resetting backoff delay");
-        this.#reconnectDelay = 5e3;
+        console.log('\u2705 Reconnection successful, resetting backoff delay')
+        this.#reconnectDelay = 5e3
       } else {
-        console.warn("\u26A0\uFE0F Reconnection attempt completed but no peers connected");
+        console.warn('\u26A0\uFE0F Reconnection attempt completed but no peers connected')
         if (this.#reconnectDelay >= 3e4) {
-          console.warn("\u26A0\uFE0F Reconnection delay reached maximum, resetting to 5 seconds");
-          this.#reconnectDelay = 5e3;
+          console.warn('\u26A0\uFE0F Reconnection delay reached maximum, resetting to 5 seconds')
+          this.#reconnectDelay = 5e3
         } else {
-          this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 3e4);
-          console.warn(`\u26A0\uFE0F Increasing reconnection delay to ${this.#reconnectDelay} ms`);
+          this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 3e4)
+          console.warn(`\u26A0\uFE0F Increasing reconnection delay to ${this.#reconnectDelay} ms`)
         }
-        this.#reconnectTimer = setTimeout(() => this.#attemptReconnection(), this.#reconnectDelay);
+        this.#reconnectTimer = setTimeout(() => this.#attemptReconnection(), this.#reconnectDelay)
       }
     } catch (error) {
-      console.error("\u274C Reconnection failed:", error?.message || error);
+      console.error('\u274C Reconnection failed:', error?.message || error)
       if (this.#reconnectDelay >= 3e4) {
-        this.#reconnectDelay = 5e3;
+        this.#reconnectDelay = 5e3
       } else {
-        this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 3e4);
+        this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 3e4)
       }
-      this.#reconnectTimer = setTimeout(() => this.#attemptReconnection(), this.#reconnectDelay);
+      this.#reconnectTimer = setTimeout(() => this.#attemptReconnection(), this.#reconnectDelay)
     }
   }
 }
 
-const debug = createDebugger("leofcoin/chain");
+const debug = createDebugger('leofcoin/chain')
 class Chain extends VersionControl {
   constructor(config) {
-    super(config);
-    this.#slotTime = 1e4;
-    this.#blockTime = 6e3;
+    super(config)
+    this.#slotTime = 1e4
+    this.#blockTime = 6e3
     // 6 second target block time
-    this.#epochLength = 10;
-    this.utils = {};
+    this.#epochLength = 10
+    this.utils = {}
     /** {Address[]} */
-    this.#validators = [];
+    this.#validators = []
     /** {Boolean} */
-    this.#runningEpoch = false;
+    this.#runningEpoch = false
     /** Block height at which current epoch started (for block-based epoch timing) */
-    this.#currentEpochStartHeight = 0;
+    this.#currentEpochStartHeight = 0
     /** {Object} Block cache by index for conflict detection: {index: {hash, ...block}} */
-    this.#blocks = {};
-    this.#participants = [];
-    this.#participating = false;
-    this.#jail = /* @__PURE__ */ new Set();
-    this.#jailReleaseTimers = /* @__PURE__ */ new Map();
-    this.#peerConnectionRetries = /* @__PURE__ */ new Map();
-    this.#maxPeerRetries = 5;
-    this.#peerRetryDelay = 5e3;
+    this.#blocks = {}
+    this.#participants = []
+    this.#participating = false
+    this.#jail = /* @__PURE__ */ new Set()
+    this.#jailReleaseTimers = /* @__PURE__ */ new Map()
+    this.#peerConnectionRetries = /* @__PURE__ */ new Map()
+    this.#maxPeerRetries = 5
+    this.#peerRetryDelay = 5e3
     /** {Map} Peer reputation tracking: {peerId: {score, failures}} */
-    this.#peerReputations = /* @__PURE__ */ new Map();
-    this.#minPeerScore = -10;
-    this.#maxPeerFailures = 100;
+    this.#peerReputations = /* @__PURE__ */ new Map()
+    this.#minPeerScore = -10
+    this.#maxPeerFailures = 100
     // ── Tendermint consensus state ──────────────────────────────────────────────
     /** Current consensus round (increments when proposer is unresponsive) */
-    this.#consensusRound = 0;
+    this.#consensusRound = 0
     /** Timer that advances #consensusRound when the proposer doesn't propose in time */
-    this.#roundTimer = null;
+    this.#roundTimer = null
     /** prevotes collected per `height:round:blockHash` key */
-    this.#prevotes = /* @__PURE__ */ new Map();
+    this.#prevotes = /* @__PURE__ */ new Map()
     /** precommits collected per `height:round:blockHash` key */
-    this.#precommits = /* @__PURE__ */ new Map();
+    this.#precommits = /* @__PURE__ */ new Map()
     /** Index of the last block that reached 2f+1 precommits */
-    this.#committedHeight = -1;
+    this.#committedHeight = -1
     /** Prevents casting duplicate prevote/precommit per height:round */
-    this.#castedVotes = /* @__PURE__ */ new Set();
+    this.#castedVotes = /* @__PURE__ */ new Set()
     this.ready = new Promise((resolve) => {
-      this.readyResolve = resolve;
-    });
+      this.readyResolve = resolve
+    })
     // ── Tendermint consensus handlers ────────────────────────────────────────
     /**
      * Publish a prevote or precommit.  Idempotent — will not cast the same
      * vote twice for the same height:round.
      */
     this.#castVote = async (type, blockHash, index, round) => {
-      const voteKey = `${type}:${index}:${round}`;
-      if (this.#castedVotes.has(voteKey)) return;
-      this.#castedVotes.add(voteKey);
-      const from = peernet.selectedAccount;
-      const voteData = { blockHash, index: BigInt(index), round: BigInt(round), from };
-      const Message = type === "prevote" ? PrevoteMessage : PrecommitMessage;
-      const message = new Message(voteData);
-      const payload = message.encoded;
+      const voteKey = `${type}:${index}:${round}`
+      if (this.#castedVotes.has(voteKey)) return
+      this.#castedVotes.add(voteKey)
+      const from = peernet.selectedAccount
+      const voteData = { blockHash, index: BigInt(index), round: BigInt(round), from }
+      const Message = type === 'prevote' ? PrevoteMessage : PrecommitMessage
+      const message = new Message(voteData)
+      const payload = message.encoded
       try {
-        globalThis.peernet.publish(`consensus:${type}`, payload);
+        globalThis.peernet.publish(`consensus:${type}`, payload)
       } catch (e) {
-        debug(`peernet publish failed: consensus:${type}`, e?.message ?? e);
+        debug(`peernet publish failed: consensus:${type}`, e?.message ?? e)
       }
-    };
+    }
     /**
      * Phase 2 — receive a block proposal from the designated proposer.
      * Validates the proposer is correct for height/round, fetches + validates
@@ -2168,72 +2212,76 @@ class Chain extends VersionControl {
      */
     this.#handleProposal = async (payload) => {
       try {
-        const message = new ProposalMessage(payload);
-        const msg = message.decoded;
-        const { blockHash, index, round, from } = msg;
-        const validators = await this.#getConsensusValidators(Number(index));
-        const expectedProposerIdx = Number((index + round) % BigInt(validators.length));
+        const message = new ProposalMessage(payload)
+        const msg = message.decoded
+        const { blockHash, index, round, from } = msg
+        const validators = await this.#getConsensusValidators(Number(index))
+        const expectedProposerIdx = Number((index + round) % BigInt(validators.length))
         if (!validators[expectedProposerIdx] || validators[expectedProposerIdx] !== from) {
-          debug(`[consensus] Proposal from wrong proposer at height ${index} round ${round}`);
-          return;
+          debug(`[consensus] Proposal from wrong proposer at height ${index} round ${round}`)
+          return
         }
-        const localBlock = await this.lastBlock;
-        const localIndex = localBlock?.index !== void 0 ? localBlock.index : -1n;
+        const localBlock = await this.lastBlock
+        const localIndex = localBlock?.index !== void 0 ? localBlock.index : -1n
         if (index <= localIndex) {
-          debug(`[consensus] Ignoring stale proposal at height ${index} (local: ${localIndex})`);
-          return;
+          debug(`[consensus] Ignoring stale proposal at height ${index} (local: ${localIndex})`)
+          return
         }
         try {
-          const blockData = await globalThis.peernet.get(blockHash, "block");
-          const blockMessage = await new BlockMessage(blockData);
-          const actualHash = await blockMessage.hash();
+          const blockData = await globalThis.peernet.get(blockHash, 'block')
+          const blockMessage = await new BlockMessage(blockData)
+          const actualHash = await blockMessage.hash()
           if (actualHash !== blockHash) {
-            debug(`[consensus] Block hash mismatch in proposal: expected ${blockHash}, got ${actualHash}`);
-            return;
+            debug(`[consensus] Block hash mismatch in proposal: expected ${blockHash}, got ${actualHash}`)
+            return
           }
         } catch (e) {
-          debug(`[consensus] Cannot fetch proposed block ${blockHash}:`, e?.message);
-          return;
+          debug(`[consensus] Cannot fetch proposed block ${blockHash}:`, e?.message)
+          return
         }
-        this.#consensusRound = Number(round);
+        this.#consensusRound = Number(round)
         if (this.#roundTimer) {
-          clearTimeout(this.#roundTimer);
-          this.#roundTimer = null;
+          clearTimeout(this.#roundTimer)
+          this.#roundTimer = null
         }
         if (validators.includes(peernet.selectedAccount) && !this.#isJailed(peernet.selectedAccount)) {
-          await this.#castVote("prevote", blockHash, Number(index), Number(round));
+          await this.#castVote('prevote', blockHash, Number(index), Number(round))
         }
       } catch (e) {
-        debug("[consensus] Error handling proposal:", e?.message);
+        debug('[consensus] Error handling proposal:', e?.message)
       }
-    };
+    }
     /**
      * Phase 2 — collect prevotes. Once 2f+1 prevotes are seen for a block,
      * cast a precommit.
      */
     this.#handlePrevote = async (payload) => {
       try {
-        const message = new PrevoteMessage(payload);
-        const msg = message.decoded;
-        const { blockHash, index, round, from } = msg;
-        const validators = await this.#getConsensusValidators(Number(index));
-        if (!validators.includes(from)) return;
-        const localBlock = await this.lastBlock;
-        const localIndex = localBlock?.index !== void 0 ? localBlock.index : -1n;
-        if (index <= localIndex) return;
-        const voteKey = `${index}:${round}:${blockHash}`;
-        if (!this.#prevotes.has(voteKey)) this.#prevotes.set(voteKey, /* @__PURE__ */ new Set());
-        this.#prevotes.get(voteKey).add(from);
-        const threshold = Math.ceil(2 * validators.length / 3);
-        const voteCount = this.#prevotes.get(voteKey).size;
-        debug(`[consensus] Prevotes ${voteKey}: ${voteCount}/${validators.length} (need ${threshold})`);
-        if (voteCount >= threshold && validators.includes(peernet.selectedAccount) && !this.#isJailed(peernet.selectedAccount)) {
-          await this.#castVote("precommit", blockHash, Number(index), Number(round));
+        const message = new PrevoteMessage(payload)
+        const msg = message.decoded
+        const { blockHash, index, round, from } = msg
+        const validators = await this.#getConsensusValidators(Number(index))
+        if (!validators.includes(from)) return
+        const localBlock = await this.lastBlock
+        const localIndex = localBlock?.index !== void 0 ? localBlock.index : -1n
+        if (index <= localIndex) return
+        const voteKey = `${index}:${round}:${blockHash}`
+        if (!this.#prevotes.has(voteKey)) this.#prevotes.set(voteKey, /* @__PURE__ */ new Set())
+        this.#prevotes.get(voteKey).add(from)
+        const threshold = Math.ceil((2 * validators.length) / 3)
+        const voteCount = this.#prevotes.get(voteKey).size
+        debug(`[consensus] Prevotes ${voteKey}: ${voteCount}/${validators.length} (need ${threshold})`)
+        if (
+          voteCount >= threshold &&
+          validators.includes(peernet.selectedAccount) &&
+          !this.#isJailed(peernet.selectedAccount)
+        ) {
+          await this.#castVote('precommit', blockHash, Number(index), Number(round))
         }
       } catch (e) {
-        debug("[consensus] Error handling prevote:", e?.message);
+        debug('[consensus] Error handling prevote:', e?.message)
       }
-    };
+    }
     /**
      * Phase 3 — collect precommits. Once 2f+1 precommits are seen for a block,
      * commit it: non-proposers call #addBlock, then broadcast on add-block for
@@ -2241,250 +2289,252 @@ class Chain extends VersionControl {
      */
     this.#handlePrecommit = async (payload) => {
       try {
-        const message = new PrecommitMessage(payload);
-        const msg = message.decoded;
-        const { blockHash, index, round, from } = msg;
-        const validators = await this.#getConsensusValidators(Number(index));
-        if (!validators.includes(from)) return;
-        if (index <= BigInt(this.#committedHeight)) return;
-        const voteKey = `${index}:${round}:${blockHash}`;
-        if (!this.#precommits.has(voteKey)) this.#precommits.set(voteKey, /* @__PURE__ */ new Set());
-        this.#precommits.get(voteKey).add(from);
-        const threshold = Math.ceil(2 * validators.length / 3);
-        const voteCount = this.#precommits.get(voteKey).size;
-        debug(`[consensus] Precommits ${voteKey}: ${voteCount}/${validators.length} (need ${threshold})`);
+        const message = new PrecommitMessage(payload)
+        const msg = message.decoded
+        const { blockHash, index, round, from } = msg
+        const validators = await this.#getConsensusValidators(Number(index))
+        if (!validators.includes(from)) return
+        if (index <= BigInt(this.#committedHeight)) return
+        const voteKey = `${index}:${round}:${blockHash}`
+        if (!this.#precommits.has(voteKey)) this.#precommits.set(voteKey, /* @__PURE__ */ new Set())
+        this.#precommits.get(voteKey).add(from)
+        const threshold = Math.ceil((2 * validators.length) / 3)
+        const voteCount = this.#precommits.get(voteKey).size
+        debug(`[consensus] Precommits ${voteKey}: ${voteCount}/${validators.length} (need ${threshold})`)
         if (voteCount >= threshold && index > BigInt(this.#committedHeight)) {
-          this.#committedHeight = Number(index);
-          this.#consensusRound = 0;
+          this.#committedHeight = Number(index)
+          this.#consensusRound = 0
           for (const key of [...this.#prevotes.keys()]) {
-            if (BigInt(key.split(":")[0]) <= index) this.#prevotes.delete(key);
+            if (BigInt(key.split(':')[0]) <= index) this.#prevotes.delete(key)
           }
           for (const key of [...this.#precommits.keys()]) {
-            if (BigInt(key.split(":")[0]) <= index) this.#precommits.delete(key);
+            if (BigInt(key.split(':')[0]) <= index) this.#precommits.delete(key)
           }
           for (const key of [...this.#castedVotes]) {
-            if (BigInt(key.split(":")[1]) <= index) this.#castedVotes.delete(key);
+            if (BigInt(key.split(':')[1]) <= index) this.#castedVotes.delete(key)
           }
-          const currentBlock = await this.lastBlock;
-          const currentIndex = currentBlock?.index !== void 0 ? currentBlock.index : -1n;
+          const currentBlock = await this.lastBlock
+          const currentIndex = currentBlock?.index !== void 0 ? currentBlock.index : -1n
           if (index > currentIndex) {
-            debug(`[consensus] \u2705 Committing block ${blockHash} at height ${index}`);
+            debug(`[consensus] \u2705 Committing block ${blockHash} at height ${index}`)
             try {
-              const blockData = await globalThis.peernet.get(blockHash, "block");
-              await this.#addBlock(blockData);
+              const blockData = await globalThis.peernet.get(blockHash, 'block')
+              await this.#addBlock(blockData)
             } catch (e) {
-              debug(`[consensus] Failed to commit block ${blockHash}:`, e?.message);
+              debug(`[consensus] Failed to commit block ${blockHash}:`, e?.message)
             }
           } else {
-            debug(`[consensus] \u2705 Block ${blockHash} at height ${index} already committed (proposer path)`);
+            debug(`[consensus] \u2705 Block ${blockHash} at height ${index} already committed (proposer path)`)
           }
           try {
-            const blockData = await globalThis.peernet.get(blockHash, "block");
-            globalThis.peernet.publish("add-block", blockData);
-            globalThis.pubsub.publish("add-block", blockData);
+            const blockData = await globalThis.peernet.get(blockHash, 'block')
+            globalThis.peernet.publish('add-block', blockData)
+            globalThis.pubsub.publish('add-block', blockData)
           } catch (e) {
-            debug("[consensus] Failed to broadcast committed block:", e?.message);
+            debug('[consensus] Failed to broadcast committed block:', e?.message)
           }
         }
       } catch (e) {
-        debug("[consensus] Error handling precommit:", e?.message);
+        debug('[consensus] Error handling precommit:', e?.message)
       }
-    };
+    }
     // ─────────────────────────────────────────────────────────────────────────
     this.#addTransaction = async (message) => {
-      const transaction = new TransactionMessage(message);
-      const hash = await transaction.hash();
-      this.addPendingNonce(transaction.decoded.from, transaction.decoded.nonce);
-      debug(`added ${hash}`);
-    };
-    this.#init();
-  }
-  #state;
-  #slotTime;
-  #blockTime;
-  #epochLength;
-  #validators;
-  #runningEpoch;
-  #currentEpochStartHeight;
-  #blocks;
-  #participants;
-  #participating;
-  #jail;
-  #jailReleaseTimers;
-  #peerConnectionRetries;
-  #maxPeerRetries;
-  #peerRetryDelay;
-  #peerReputations;
-  #minPeerScore;
-  #maxPeerFailures;
-  #consensusRound;
-  #roundTimer;
-  #prevotes;
-  #precommits;
-  #committedHeight;
-  #castedVotes;
+      const transaction = new TransactionMessage(message)
+      const hash = await transaction.hash()
+      this.addPendingNonce(transaction.decoded.from, transaction.decoded.nonce)
+      debug(`added ${hash}`)
+    }
+    this.#init()
+  }
+  #state
+  #slotTime
+  #blockTime
+  #epochLength
+  #validators
+  #runningEpoch
+  #currentEpochStartHeight
+  #blocks
+  #participants
+  #participating
+  #jail
+  #jailReleaseTimers
+  #peerConnectionRetries
+  #maxPeerRetries
+  #peerRetryDelay
+  #peerReputations
+  #minPeerScore
+  #maxPeerFailures
+  #consensusRound
+  #roundTimer
+  #prevotes
+  #precommits
+  #committedHeight
+  #castedVotes
   // ────────────────────────────────────────────────────────────────────────────
-  #connectionMonitor;
+  #connectionMonitor
   get nativeToken() {
-    return addresses.nativeToken;
+    return addresses.nativeToken
   }
   get validators() {
-    return [...this.#validators];
+    return [...this.#validators]
   }
   async hasTransactionToHandle() {
-    const size = await globalThis.transactionPoolStore.size();
-    if (size > 0) return true;
-    return false;
+    const size = await globalThis.transactionPoolStore.size()
+    if (size > 0) return true
+    return false
   }
   #sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms))
   }
   async #recordPeerFailure(peerId, reason) {
     if (!this.#peerReputations.has(peerId)) {
-      this.#peerReputations.set(peerId, { score: 0, failures: [] });
+      this.#peerReputations.set(peerId, { score: 0, failures: [] })
     }
-    const rep = this.#peerReputations.get(peerId);
-    rep.score -= 1;
-    rep.failures.push(`${Date.now()}: ${reason}`);
+    const rep = this.#peerReputations.get(peerId)
+    rep.score -= 1
+    rep.failures.push(`${Date.now()}: ${reason}`)
     if (rep.failures.length > this.#maxPeerFailures) {
-      rep.failures.shift();
+      rep.failures.shift()
     }
     if (rep.score < this.#minPeerScore) {
-      console.warn(`[peer-ban] Peer ${peerId} banned after ${rep.failures.length} failures`);
+      console.warn(`[peer-ban] Peer ${peerId} banned after ${rep.failures.length} failures`)
       try {
-        await globalThis.peernet.disconnect(peerId);
+        await globalThis.peernet.disconnect(peerId)
       } catch (e) {
-        debug(`Failed to disconnect peer ${peerId}`);
+        debug(`Failed to disconnect peer ${peerId}`)
       }
     }
   }
   #isJailed(address) {
-    return typeof address === "string" && this.#jail.has(address);
+    return typeof address === 'string' && this.#jail.has(address)
   }
   async #getConsensusValidators(nextBlockIndex) {
-    const localBlock = await this.lastBlock;
-    const localIndex = localBlock?.index !== void 0 ? Number(localBlock.index) : -1;
-    if (Array.isArray(localBlock?.validators) && localBlock.validators.length > 0 && (nextBlockIndex === void 0 || nextBlockIndex === localIndex + 1)) {
+    const localBlock = await this.lastBlock
+    const localIndex = localBlock?.index !== void 0 ? Number(localBlock.index) : -1
+    if (
+      Array.isArray(localBlock?.validators) &&
+      localBlock.validators.length > 0 &&
+      (nextBlockIndex === void 0 || nextBlockIndex === localIndex + 1)
+    ) {
       return [
-        ...new Set(
-          localBlock.validators.map((validator) => validator.address).filter((address) => Boolean(address))
-        )
-      ].sort();
+        ...new Set(localBlock.validators.map((validator) => validator.address).filter((address) => Boolean(address)))
+      ].sort()
     }
-    const validators = await this.staticCall(addresses.validators, "validators");
-    return [...new Set(validators)].sort();
+    const validators = await this.staticCall(addresses.validators, 'validators')
+    return [...new Set(validators)].sort()
   }
   #validateBlockValidators(blockMessage) {
-    const validators = blockMessage.decoded.validators || [];
+    const validators = blockMessage.decoded.validators || []
     if (!Array.isArray(validators) || validators.length === 0) {
-      throw new Error(`Block ${blockMessage.decoded.index} does not include validators`);
+      throw new Error(`Block ${blockMessage.decoded.index} does not include validators`)
     }
-    if (!blockMessage.decoded.protocolVersion || typeof blockMessage.decoded.protocolVersion !== "string") {
-      throw new Error(`Block ${blockMessage.decoded.index} does not have a valid protocolVersion field`);
+    if (!blockMessage.decoded.protocolVersion || typeof blockMessage.decoded.protocolVersion !== 'string') {
+      throw new Error(`Block ${blockMessage.decoded.index} does not have a valid protocolVersion field`)
     }
     if (!this.isVersionCompatible(blockMessage.decoded.protocolVersion)) {
       throw new Error(
         `Block ${blockMessage.decoded.index} uses incompatible protocol version: ${blockMessage.decoded.protocolVersion} (local: ${this.version}). Major.minor version must match.`
-      );
+      )
     }
-    if (!blockMessage.decoded.producer || typeof blockMessage.decoded.producer !== "string") {
-      throw new Error(`Block ${blockMessage.decoded.index} does not have a valid producer field`);
+    if (!blockMessage.decoded.producer || typeof blockMessage.decoded.producer !== 'string') {
+      throw new Error(`Block ${blockMessage.decoded.index} does not have a valid producer field`)
     }
-    if (!blockMessage.decoded.producerProof || typeof blockMessage.decoded.producerProof !== "string") {
-      throw new Error(`Block ${blockMessage.decoded.index} does not have a valid producerProof field`);
+    if (!blockMessage.decoded.producerProof || typeof blockMessage.decoded.producerProof !== 'string') {
+      throw new Error(`Block ${blockMessage.decoded.index} does not have a valid producerProof field`)
     }
-    const producerIsValidator = validators.some((v) => v.address === blockMessage.decoded.producer);
+    const producerIsValidator = validators.some((v) => v.address === blockMessage.decoded.producer)
     if (!producerIsValidator) {
       throw new Error(
         `Block ${blockMessage.decoded.index} producer ${blockMessage.decoded.producer} is not in validators list`
-      );
+      )
     }
-    const addresses2 = validators.map((validator) => validator.address);
-    if (addresses2.some((address) => typeof address !== "string" || address.length === 0)) {
-      throw new Error(`Block ${blockMessage.decoded.index} includes an invalid validator address`);
+    const addresses2 = validators.map((validator) => validator.address)
+    if (addresses2.some((address) => typeof address !== 'string' || address.length === 0)) {
+      throw new Error(`Block ${blockMessage.decoded.index} includes an invalid validator address`)
     }
-    const canonicalAddresses = [...addresses2].sort();
+    const canonicalAddresses = [...addresses2].sort()
     if (canonicalAddresses.some((address, index) => address !== addresses2[index])) {
-      throw new Error(`Block ${blockMessage.decoded.index} validators are not canonically sorted`);
+      throw new Error(`Block ${blockMessage.decoded.index} validators are not canonically sorted`)
     }
     if (new Set(addresses2).size !== addresses2.length) {
-      throw new Error(`Block ${blockMessage.decoded.index} validators contain duplicates`);
+      throw new Error(`Block ${blockMessage.decoded.index} validators contain duplicates`)
     }
-    const validatorCount = BigInt(validators.length);
-    const expectedReward = blockMessage.decoded.fees / validatorCount + blockMessage.decoded.reward / validatorCount;
+    const validatorCount = BigInt(validators.length)
+    const expectedReward = blockMessage.decoded.fees / validatorCount + blockMessage.decoded.reward / validatorCount
     for (const validator of validators) {
       if (validator.reward !== expectedReward) {
         throw new Error(
           `Block ${blockMessage.decoded.index} has an invalid reward for validator ${validator.address}: expected ${expectedReward}, got ${validator.reward}`
-        );
+        )
       }
     }
   }
   /** Check if the next block will cross an epoch boundary (block-based timing) */
   #isEpochBoundary(blockHeight) {
-    return (blockHeight + 1) % this.#epochLength === 0;
+    return (blockHeight + 1) % this.#epochLength === 0
   }
   /** Handle epoch transition when a block crosses epoch boundary */
   async #handleEpochBoundary(blockHeight) {
-    if (!this.#isEpochBoundary(blockHeight)) return;
-    this.#currentEpochStartHeight = blockHeight + 1;
-    this.#consensusRound = 0;
+    if (!this.#isEpochBoundary(blockHeight)) return
+    this.#currentEpochStartHeight = blockHeight + 1
+    this.#consensusRound = 0
     debug(
       `[consensus] Epoch boundary at block ${blockHeight}: new epoch starts at height ${this.#currentEpochStartHeight}`
-    );
+    )
     if (this.#participating && !this.#runningEpoch) {
-      await this.#runEpoch();
+      await this.#runEpoch()
     }
   }
   async #runEpoch() {
-    if (this.#runningEpoch) return;
-    this.#runningEpoch = true;
-    console.log("epoch");
-    const validators = await this.#getConsensusValidators();
-    console.log({ validators });
+    if (this.#runningEpoch) return
+    this.#runningEpoch = true
+    console.log('epoch')
+    const validators = await this.#getConsensusValidators()
+    console.log({ validators })
     if (this.#isJailed(peernet.selectedAccount)) {
-      this.#runningEpoch = false;
-      return;
+      this.#runningEpoch = false
+      return
     }
     if (!validators.includes(peernet.selectedAccount)) {
-      this.#runningEpoch = false;
-      return;
+      this.#runningEpoch = false
+      return
     }
-    const localBlock = await this.lastBlock;
-    const nextIndex = (localBlock?.index !== void 0 ? Number(localBlock.index) : -1) + 1;
-    const proposerIdx = (nextIndex + this.#consensusRound) % validators.length;
-    const isProposer = validators[proposerIdx] === peernet.selectedAccount;
+    const localBlock = await this.lastBlock
+    const nextIndex = (localBlock?.index !== void 0 ? Number(localBlock.index) : -1) + 1
+    const proposerIdx = (nextIndex + this.#consensusRound) % validators.length
+    const isProposer = validators[proposerIdx] === peernet.selectedAccount
     if (!isProposer) {
       if (!this.#roundTimer) {
         this.#roundTimer = setTimeout(async () => {
-          this.#roundTimer = null;
-          this.#consensusRound++;
-          debug(`[consensus] Round timed out, advancing to round ${this.#consensusRound}`);
-          this.#runningEpoch = false;
-          if (this.#participating) await this.#runEpoch();
-        }, this.#slotTime);
+          this.#roundTimer = null
+          this.#consensusRound++
+          debug(`[consensus] Round timed out, advancing to round ${this.#consensusRound}`)
+          this.#runningEpoch = false
+          if (this.#participating) await this.#runEpoch()
+        }, this.#slotTime)
       }
-      this.#runningEpoch = false;
-      return;
+      this.#runningEpoch = false
+      return
     }
     if (this.#roundTimer) {
-      clearTimeout(this.#roundTimer);
-      this.#roundTimer = null;
+      clearTimeout(this.#roundTimer)
+      this.#roundTimer = null
     }
-    const start = Date.now();
+    const start = Date.now()
     try {
-      await this.#createBlock();
+      await this.#createBlock()
     } catch (error) {
-      console.error(error);
+      console.error(error)
     }
-    const end = Date.now();
-    console.log((end - start) / 1e3 + " s");
-    const elapsed = end - start;
-    const remaining = this.#blockTime - elapsed;
-    const hasMore = await this.hasTransactionToHandle();
-    if (!hasMore && remaining > 0) await this.#sleep(remaining);
-    this.#runningEpoch = false;
-    if (hasMore) return this.#runEpoch();
+    const end = Date.now()
+    console.log((end - start) / 1e3 + ' s')
+    const elapsed = end - start
+    const remaining = this.#blockTime - elapsed
+    const hasMore = await this.hasTransactionToHandle()
+    if (!hasMore && remaining > 0) await this.#sleep(remaining)
+    this.#runningEpoch = false
+    if (hasMore) return this.#runEpoch()
   }
   async #setup() {
     const contracts = [
@@ -2504,684 +2554,706 @@ class Chain extends VersionControl {
         address: addresses.nameService,
         message: nameServiceMessage
       }
-    ];
+    ]
     await Promise.all(
       contracts.map(async ({ address, message }) => {
-        message = await new ContractMessage(Uint8Array.from(message.split(",").map((string) => Number(string))));
-        await globalThis.contractStore.put(address, message.encoded);
+        message = await new ContractMessage(Uint8Array.from(message.split(',').map((string) => Number(string))))
+        await globalThis.contractStore.put(address, message.encoded)
       })
-    );
-    console.log("handle native contracts");
+    )
+    console.log('handle native contracts')
   }
   async #init() {
-    this.#participants = [];
-    this.#participating = false;
-    this.#connectionMonitor = new ConnectionMonitor();
-    console.log("[chain] init:start");
-    const initialized = await globalThis.contractStore.has(addresses.contractFactory);
-    console.log(`chain initialized: ${initialized}`);
-    if (!initialized) await this.#setup();
-    this.utils = { formatUnits, parseUnits };
-    console.log("init");
-    await super.init();
-    console.log("super init done");
-    this.#connectionMonitor.start(this.version);
-    await globalThis.peernet.addRequestHandler("bw-request-message", () => {
-      const bw = globalThis.peernet.client?.bw || { up: 0, down: 0 };
-      return new BWMessage(bw);
-    });
-    await globalThis.peernet.addRequestHandler("transactionPool", this.#transactionPoolHandler.bind(this));
-    await globalThis.peernet.addRequestHandler("version", this.#versionHandler.bind(this));
-    await globalThis.peernet.addRequestHandler("stateInfo", async () => {
-      const lastblock = await this.lastBlock || { index: 0, hash: "0x0", previousHash: "0x0" };
-      const values = this.machine?.states?.info || {};
-      return new globalThis.peernet.protos["peernet-response"]({
+    this.#participants = []
+    this.#participating = false
+    this.#connectionMonitor = new ConnectionMonitor()
+    console.log('[chain] init:start')
+    const initialized = await globalThis.contractStore.has(addresses.contractFactory)
+    console.log(`chain initialized: ${initialized}`)
+    if (!initialized) await this.#setup()
+    this.utils = { formatUnits, parseUnits }
+    console.log('init')
+    await super.init()
+    console.log('super init done')
+    this.#connectionMonitor.start(this.version)
+    await globalThis.peernet.addRequestHandler('bw-request-message', () => {
+      const bw = globalThis.peernet.client?.bw || { up: 0, down: 0 }
+      return new BWMessage(bw)
+    })
+    await globalThis.peernet.addRequestHandler('transactionPool', this.#transactionPoolHandler.bind(this))
+    await globalThis.peernet.addRequestHandler('version', this.#versionHandler.bind(this))
+    await globalThis.peernet.addRequestHandler('stateInfo', async () => {
+      const lastblock = (await this.lastBlock) || { index: 0, hash: '0x0', previousHash: '0x0' }
+      const values = this.machine?.states?.info || {}
+      return new globalThis.peernet.protos['peernet-response']({
         response: new StateMessage({ lastblock, values }).encoded
-      });
-    });
-    globalThis.peernet.subscribe("add-block", this.#addBlock.bind(this));
-    globalThis.peernet.subscribe("invalid-transaction", this.#invalidTransaction.bind(this));
-    globalThis.peernet.subscribe("send-transaction", this.#sendTransaction.bind(this));
-    globalThis.peernet.subscribe("add-transaction", this.#addTransaction.bind(this));
-    globalThis.peernet.subscribe("validator:timeout", this.#validatorTimeout.bind(this));
-    globalThis.peernet.subscribe("consensus:propose", this.#handleProposal.bind(this));
-    globalThis.peernet.subscribe("consensus:prevote", this.#handlePrevote.bind(this));
-    globalThis.peernet.subscribe("consensus:precommit", this.#handlePrecommit.bind(this));
-    globalThis.pubsub.subscribe("peer:connected", this.#peerConnected.bind(this));
-    globalThis.pubsub.publish("chain:ready", true);
-    console.log("[chain] init:done");
-    this.readyResolve(true);
+      })
+    })
+    globalThis.peernet.subscribe('add-block', this.#addBlock.bind(this))
+    globalThis.peernet.subscribe('invalid-transaction', this.#invalidTransaction.bind(this))
+    globalThis.peernet.subscribe('send-transaction', this.#sendTransaction.bind(this))
+    globalThis.peernet.subscribe('add-transaction', this.#addTransaction.bind(this))
+    globalThis.peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this))
+    globalThis.peernet.subscribe('consensus:propose', this.#handleProposal.bind(this))
+    globalThis.peernet.subscribe('consensus:prevote', this.#handlePrevote.bind(this))
+    globalThis.peernet.subscribe('consensus:precommit', this.#handlePrecommit.bind(this))
+    globalThis.pubsub.subscribe('peer:connected', this.#peerConnected.bind(this))
+    globalThis.pubsub.publish('chain:ready', true)
+    console.log('[chain] init:done')
+    this.readyResolve(true)
   }
   async #invalidTransaction(hash) {
-    hash = new TextDecoder().decode(hash);
-    if (!await globalThis.transactionPoolStore.has(hash)) {
-      debug(`transaction ${hash} not in pool`);
-      return;
+    hash = new TextDecoder().decode(hash)
+    if (!(await globalThis.transactionPoolStore.has(hash))) {
+      debug(`transaction ${hash} not in pool`)
+      return
     }
-    console.log(`removing invalid transaction: ${hash}`);
-    await globalThis.transactionPoolStore.delete(hash);
+    console.log(`removing invalid transaction: ${hash}`)
+    await globalThis.transactionPoolStore.delete(hash)
   }
   async #validatorTimeout(validatorInfo) {
-    const address = validatorInfo?.address;
-    if (!address) return;
-    const timeout = Math.min(Math.max(Number(validatorInfo.timeout) || 0, 0), 60 * 60 * 1e3);
-    const existingRelease = this.#jailReleaseTimers.get(address);
-    if (existingRelease) clearTimeout(existingRelease);
-    this.#jail.add(address);
+    const address = validatorInfo?.address
+    if (!address) return
+    const timeout = Math.min(Math.max(Number(validatorInfo.timeout) || 0, 0), 60 * 60 * 1e3)
+    const existingRelease = this.#jailReleaseTimers.get(address)
+    if (existingRelease) clearTimeout(existingRelease)
+    this.#jail.add(address)
     const releaseTimer = setTimeout(() => {
-      this.#jail.delete(address);
-      this.#jailReleaseTimers.delete(address);
-    }, timeout);
-    this.#jailReleaseTimers.set(address, releaseTimer);
-  }
-  #castVote;
-  #handleProposal;
-  #handlePrevote;
-  #handlePrecommit;
-  #addTransaction;
+      this.#jail.delete(address)
+      this.#jailReleaseTimers.delete(address)
+    }, timeout)
+    this.#jailReleaseTimers.set(address, releaseTimer)
+  }
+  #castVote
+  #handleProposal
+  #handlePrevote
+  #handlePrecommit
+  #addTransaction
   async #prepareRequest(request) {
-    let node = await new globalThis.peernet.protos["peernet-request"]({ request });
-    return globalThis.peernet.prepareMessage(node);
+    let node = await new globalThis.peernet.protos['peernet-request']({ request })
+    return globalThis.peernet.prepareMessage(node)
   }
   async #makeRequest(peer, request) {
-    const node = await this.#prepareRequest(request);
+    const node = await this.#prepareRequest(request)
     try {
-      let response = await peer.request(node.encoded);
-      response = await new globalThis.peernet.protos["peernet-response"](response);
-      const decodeResponse = async (payload) => {
-        if (!(payload instanceof Uint8Array)) return payload;
-        for (let i = 0; i < 3; i++) {
-          try {
-            const nested = await new globalThis.peernet.protos["peernet-response"](payload);
-            payload = nested?.decoded?.response;
-            if (!(payload instanceof Uint8Array)) break;
-          } catch {
-            break;
+      let response = await peer.request(node.encoded)
+      if (response === undefined || response === null) return response
+      const normalizeResponse = async (payload) => {
+        if (payload === undefined || payload === null) return payload
+        if (payload && typeof payload === 'object') {
+          if ('decoded' in payload && payload.decoded && 'response' in payload.decoded) {
+            return normalizeResponse(payload.decoded.response)
+          }
+          if ('response' in payload) {
+            return normalizeResponse(payload.response)
           }
         }
-        if (payload instanceof Uint8Array) {
+        if (payload instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(payload))) {
+          return payload instanceof Uint8Array ? payload : new Uint8Array(payload)
+        }
+        if (typeof payload === 'string') {
           try {
-            return JSON.parse(new TextDecoder().decode(payload));
+            return JSON.parse(payload)
           } catch {
-            return payload;
+            return payload
           }
         }
-        return payload;
-      };
-      return await decodeResponse(response.decoded.response);
+        return payload
+      }
+      return await normalizeResponse(response)
     } catch (error) {
-      const peerId = peer?.peerId || peer?.id || peer?.address || "unknown";
-      debug(`peernet request failed: ${request} -> ${peerId}:`, error?.message ?? error);
-      throw error;
+      const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown'
+      debug(`peernet request failed: ${request} -> ${peerId}:`, error?.message ?? error)
+      throw error
     }
   }
   async #decodeKnownBlocksResponse(response) {
-    if (!response) return null;
+    if (!response) return null
     if (Array.isArray(response)) {
-      return { blocks: response };
+      return { blocks: response }
     }
     if (Array.isArray(response.blocks)) {
-      return { blocks: response.blocks };
+      return { blocks: response.blocks }
     }
     if (response.response && Array.isArray(response.response.blocks)) {
-      return { blocks: response.response.blocks };
+      return { blocks: response.response.blocks }
     }
-    if (typeof response === "string") {
+    if (typeof response === 'string') {
       try {
-        const parsed = JSON.parse(response);
-        if (Array.isArray(parsed)) return { blocks: parsed };
-        if (parsed && Array.isArray(parsed.blocks)) return { blocks: parsed.blocks };
-        if (parsed?.response && Array.isArray(parsed.response.blocks)) return { blocks: parsed.response.blocks };
+        const parsed = JSON.parse(response)
+        if (Array.isArray(parsed)) return { blocks: parsed }
+        if (parsed && Array.isArray(parsed.blocks)) return { blocks: parsed.blocks }
+        if (parsed?.response && Array.isArray(parsed.response.blocks)) return { blocks: parsed.response.blocks }
       } catch {
-        return null;
+        return null
       }
-      return null;
+      return null
     }
-    if (!(response instanceof Uint8Array)) return null;
-    let payload = response;
+    if (!(response instanceof Uint8Array)) return null
+    let payload = response
     for (let i = 0; i < 3; i++) {
-      if (!(payload instanceof Uint8Array)) break;
+      if (!(payload instanceof Uint8Array)) break
       try {
-        const nestedResponse = await new globalThis.peernet.protos["peernet-response"](payload);
-        payload = nestedResponse?.decoded?.response;
+        const nestedResponse = await new globalThis.peernet.protos['peernet-response'](payload)
+        payload = nestedResponse?.decoded?.response
       } catch {
-        break;
+        break
       }
     }
-    if (Array.isArray(payload)) return { blocks: payload };
-    if (payload && Array.isArray(payload.blocks)) return { blocks: payload.blocks };
-    if (payload?.response && Array.isArray(payload.response.blocks)) return { blocks: payload.response.blocks };
+    if (Array.isArray(payload)) return { blocks: payload }
+    if (payload && Array.isArray(payload.blocks)) return { blocks: payload.blocks }
+    if (payload?.response && Array.isArray(payload.response.blocks)) return { blocks: payload.response.blocks }
     try {
-      const decoded = new TextDecoder().decode(response);
-      const parsed = JSON.parse(decoded);
-      if (Array.isArray(parsed)) return { blocks: parsed };
-      if (parsed && Array.isArray(parsed.blocks)) return { blocks: parsed.blocks };
-      if (parsed?.response && Array.isArray(parsed.response.blocks)) return { blocks: parsed.response.blocks };
+      const decoded = new TextDecoder().decode(response)
+      const parsed = JSON.parse(decoded)
+      if (Array.isArray(parsed)) return { blocks: parsed }
+      if (parsed && Array.isArray(parsed.blocks)) return { blocks: parsed.blocks }
+      if (parsed?.response && Array.isArray(parsed.response.blocks)) return { blocks: parsed.response.blocks }
     } catch {
-      return null;
+      return null
     }
-    return null;
+    return null
   }
   async getPeerTransactionPool(peer) {
-    let transactionsInPool = await this.#makeRequest(peer, "transactionPool");
+    let transactionsInPool = await this.#makeRequest(peer, 'transactionPool')
     if (transactionsInPool instanceof Uint8Array) {
-      debug("transactionPool response must be decoded array payload");
-      return [];
+      debug('transactionPool response must be decoded array payload')
+      return []
     }
-    if (!Array.isArray(transactionsInPool)) return [];
-    const localTransactions = new Set(await globalThis.transactionPoolStore.keys());
-    const transactionsToGet = [];
+    if (!Array.isArray(transactionsInPool)) return []
+    const localTransactions = new Set(await globalThis.transactionPoolStore.keys())
+    const transactionsToGet = []
     for (const key of transactionsInPool) {
       if (!localTransactions.has(key)) {
-        let txData;
+        let txData
         try {
-          txData = await globalThis.peernet.get(key, "transaction");
+          txData = await globalThis.peernet.get(key, 'transaction')
         } catch (error) {
-          debug(`Failed to get transaction ${key}:`, error?.message ?? error);
+          debug(`Failed to get transaction ${key}:`, error?.message ?? error)
         }
         if (txData !== void 0) {
-          transactionsToGet.push(transactionPoolStore.put(key, txData));
+          transactionsToGet.push(transactionPoolStore.put(key, txData))
         }
       }
     }
-    return Promise.all(transactionsToGet);
+    return Promise.all(transactionsToGet)
   }
   async #peerConnected(peerId) {
-    debug(`peer connected: ${peerId}`);
-    const peer = peernet.getConnection(peerId);
+    debug(`peer connected: ${peerId}`)
+    const peer = peernet.getConnection(peerId)
     if (!peer) {
-      debug(`peer not found: ${peerId}`);
-      return;
+      debug(`peer not found: ${peerId}`)
+      return
     }
     if (!peer.version) {
       try {
-        let versionResponse = await this.#makeRequest(peer, "version");
+        let versionResponse = await this.#makeRequest(peer, 'version')
         if (versionResponse instanceof Uint8Array) {
-          versionResponse = new TextDecoder().decode(versionResponse);
+          versionResponse = new TextDecoder().decode(versionResponse)
         }
-        if (typeof versionResponse === "string") {
-          peer.version = versionResponse;
-        } else if (versionResponse && typeof versionResponse === "object" && typeof versionResponse.version === "string") {
-          peer.version = versionResponse.version;
+        if (typeof versionResponse === 'string') {
+          peer.version = versionResponse
+        } else if (
+          versionResponse &&
+          typeof versionResponse === 'object' &&
+          typeof versionResponse.version === 'string'
+        ) {
+          peer.version = versionResponse.version
         }
-        if (!peer.version || typeof peer.version !== "string") {
-          const reason = `invalid version response from peer ${peerId}`;
-          debug(reason);
-          await this.#recordPeerFailure(peerId, reason);
-          return;
+        if (!peer.version || typeof peer.version !== 'string') {
+          const reason = `invalid version response from peer ${peerId}`
+          debug(reason)
+          await this.#recordPeerFailure(peerId, reason)
+          return
         }
       } catch (error) {
-        debug(`failed to request version from peer ${peerId}:`, error?.message ?? error);
-        return;
+        debug(`failed to request version from peer ${peerId}:`, error?.message ?? error)
+        return
       }
     }
-    debug(`peer connected with version ${peer.version}`);
+    debug(`peer connected with version ${peer.version}`)
     if (!this.isVersionCompatible(peer.version)) {
-      const mismatchReason = `incompatible peer version ${peer.version} (local: ${this.version})`;
-      console.error(`[chain] ${mismatchReason}`);
-      await this.#recordPeerFailure(peerId, mismatchReason);
-      return;
+      const mismatchReason = `incompatible peer version ${peer.version} (local: ${this.version})`
+      console.error(`[chain] ${mismatchReason}`)
+      await this.#recordPeerFailure(peerId, mismatchReason)
+      return
     }
-    let lastBlock;
+    let lastBlock
     try {
-      console.log("requesting last block from peer...");
-      console.log(await this.lastBlock);
-      const lastBlockRaw = await this.#makeRequest(peer, "lastBlock");
-      console.log(new LastBlockMessage(lastBlockRaw));
-      lastBlock = new LastBlockMessage(lastBlockRaw).decoded;
+      console.log('requesting last block from peer...')
+      console.log(await this.lastBlock)
+      console.log('peer response:')
+      const lastBlockRaw = await this.#makeRequest(peer, 'lastBlock')
+      if (
+        lastBlockRaw === undefined ||
+        lastBlockRaw === null ||
+        (typeof lastBlockRaw !== 'object' && !(lastBlockRaw instanceof Uint8Array))
+      ) {
+        throw new Error(`invalid lastBlock payload: ${typeof lastBlockRaw}`)
+      }
+      console.log('raw last block response:', lastBlockRaw)
+      console.log(new LastBlockMessage(lastBlockRaw))
+      lastBlock = new LastBlockMessage(lastBlockRaw).decoded
     } catch (error) {
-      const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
-      debug(`lastBlock request failed: ${peerName}:`, error?.message ?? error);
-      await this.#recordPeerFailure(peerId, `lastBlock request failed: ${error?.message ?? error}`);
-      return;
+      const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown'
+      debug(`lastBlock request failed: ${peerName}:`, error?.message ?? error)
+      await this.#recordPeerFailure(peerId, `lastBlock request failed: ${error?.message ?? error}`)
+      return
     }
-    const localBlock = await this.lastBlock;
-    const MAX_SYNC_AHEAD = 1e5;
+    const localBlock = await this.lastBlock
+    const MAX_SYNC_AHEAD = 1e5
     if (lastBlock?.index > BigInt(localBlock?.index ?? 0) + BigInt(MAX_SYNC_AHEAD)) {
-      const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
-      debug(`Peer ${peerName} claims unreasonable block height ${lastBlock.index} (local: ${localBlock?.index ?? 0})`);
-      await this.#recordPeerFailure(peerId, `unreasonable lastBlock index: ${lastBlock.index}`);
-      return;
+      const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown'
+      debug(`Peer ${peerName} claims unreasonable block height ${lastBlock.index} (local: ${localBlock?.index ?? 0})`)
+      await this.#recordPeerFailure(peerId, `unreasonable lastBlock index: ${lastBlock.index}`)
+      return
     }
-    if (!lastBlock || !lastBlock.hash || lastBlock.hash === "0x0") {
-      debug(`peer has no lastBlock: ${peerId}`);
-      return;
+    if (!lastBlock || !lastBlock.hash || lastBlock.hash === '0x0') {
+      debug(`peer has no lastBlock: ${peerId}`)
+      return
     }
-    const higherThenCurrentLocal = !localBlock?.index ? true : lastBlock.index > localBlock.index;
+    const higherThenCurrentLocal = !localBlock?.index ? true : lastBlock.index > localBlock.index
     if (lastBlock) {
       if (!this.lastBlock || higherThenCurrentLocal) {
         try {
-          const knownBlocksRaw = await this.#makeRequest(peer, "knownBlocks");
-          const knownBlocksResponse = await this.#decodeKnownBlocksResponse(knownBlocksRaw);
+          const knownBlocksRaw = await this.#makeRequest(peer, 'knownBlocks')
+          const knownBlocksResponse = await this.#decodeKnownBlocksResponse(knownBlocksRaw)
           if (!knownBlocksResponse) {
             debug(
               `knownBlocks decode failed for peer ${peerId} (non-fatal), continuing sync without prefilled wantList`
-            );
+            )
           } else {
-            const MAX_WANTLIST_SIZE = 1e3;
-            const remaining = MAX_WANTLIST_SIZE - this.wantList.length;
+            const MAX_WANTLIST_SIZE = 1e3
+            const remaining = MAX_WANTLIST_SIZE - this.wantList.length
             if (remaining > 0) {
               for (const hash of knownBlocksResponse.blocks.slice(0, remaining)) {
-                this.wantList.push(hash);
+                this.wantList.push(hash)
               }
             }
           }
         } catch (error) {
-          const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
+          const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown'
           debug(
             `knownBlocks request failed: ${peerName} (non-fatal), continuing sync without prefilled wantList:`,
             error?.message ?? error
-          );
+          )
         }
       }
     }
     if (this.wantList.length > 0) {
-      const promises = await Promise.allSettled(this.wantList.map((hash) => peernet.get(hash, "block")));
+      const promises = await Promise.allSettled(this.wantList.map((hash) => peernet.get(hash, 'block')))
       for (let i = 0; i < promises.length; i++) {
-        const result = promises[i];
-        if (result.status === "fulfilled") this.wantList.splice(i, 1);
+        const result = promises[i]
+        if (result.status === 'fulfilled') this.wantList.splice(i, 1)
       }
-      if (this.wantList.length === 0) await this.triggerSync();
+      if (this.wantList.length === 0) await this.triggerSync()
     }
     setTimeout(async () => {
       try {
-        const peerTransactionPool = higherThenCurrentLocal && await this.getPeerTransactionPool(peer) || [];
-        if (this.#participating && peerTransactionPool.length > 0) return this.#runEpoch();
+        const peerTransactionPool = (higherThenCurrentLocal && (await this.getPeerTransactionPool(peer))) || []
+        if (this.#participating && peerTransactionPool.length > 0) return this.#runEpoch()
       } catch (error) {
-        const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
-        debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error);
+        const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown'
+        debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error)
       }
-    }, 3e3);
+    }, 3e3)
     try {
-      let stateInfo = await this.#makeRequest(peer, "stateInfo");
+      let stateInfo = await this.#makeRequest(peer, 'stateInfo')
       if (stateInfo instanceof Uint8Array) {
-        const decodedStateInfo = new StateMessage(stateInfo).decoded;
-        stateInfo = decodedStateInfo?.values ?? decodedStateInfo;
+        const decodedStateInfo = new StateMessage(stateInfo).decoded
+        stateInfo = decodedStateInfo?.values ?? decodedStateInfo
       }
       debug(
-        `sync start with peer ${peerId}: local=${localBlock?.index ?? -1} remote=${lastBlock?.index ?? -1} hash=${lastBlock?.hash}`
-      );
-      await this.syncChain(lastBlock);
+        `sync start with peer ${peerId}: local=${localBlock?.index ?? -1} remote=${lastBlock?.index ?? -1} hash=${
+          lastBlock?.hash
+        }`
+      )
+      await this.syncChain(lastBlock)
       debug(
         `sync finished with peer ${peerId}: state=${this.syncState} localNow=${(await this.lastBlock)?.index ?? -1}`
-      );
-      this.machine.states.info = stateInfo;
+      )
+      this.machine.states.info = stateInfo
     } catch (error) {
-      const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
-      debug(`stateInfo/syncChain failed: ${peerName}:`, error?.message ?? error);
-      await this.#recordPeerFailure(peerId, `stateInfo/syncChain failed: ${error?.message ?? error}`);
-      return;
+      const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown'
+      debug(`stateInfo/syncChain failed: ${peerName}:`, error?.message ?? error)
+      await this.#recordPeerFailure(peerId, `stateInfo/syncChain failed: ${error?.message ?? error}`)
+      return
     }
   }
-  #epochTimeout;
+  #epochTimeout
   async #transactionPoolHandler() {
-    const pool = await globalThis.transactionPoolStore.keys();
-    return new globalThis.peernet.protos["peernet-response"]({ response: pool });
+    const pool = await globalThis.transactionPoolStore.keys()
+    return new globalThis.peernet.protos['peernet-response']({ response: pool })
   }
   async #versionHandler() {
-    return new globalThis.peernet.protos["peernet-response"]({ response: this.version });
+    return new globalThis.peernet.protos['peernet-response']({ response: this.version })
   }
   async #executeTransaction({ hash, from, to, method, params, nonce }) {
     try {
-      let result = await this.machine.execute(to, method, params);
-      globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: "fulfilled", hash });
-      return result || "no state change";
+      let result = await this.machine.execute(to, method, params)
+      globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: 'fulfilled', hash })
+      return result || 'no state change'
     } catch (error) {
-      await transactionPoolStore.delete(hash);
+      await transactionPoolStore.delete(hash)
       try {
-        globalThis.peernet.publish("invalid-transaction", hash);
+        globalThis.peernet.publish('invalid-transaction', hash)
       } catch (publishError) {
-        debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
+        debug('peernet publish failed: invalid-transaction', publishError?.message ?? publishError)
       }
-      globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: "fail", hash, error });
-      throw { error, hash, from, to, params, nonce };
+      globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: 'fail', hash, error })
+      throw { error, hash, from, to, params, nonce }
     }
   }
   async #addBlock(block) {
-    const receivedEncoded = block instanceof BlockMessage ? block.encoded : block;
-    const blockMessage = await new BlockMessage(block);
-    const hash = await blockMessage.hash();
-    const blockIndex = Number(blockMessage.decoded.index);
-    const existingBlockAtHeight = this.#blocks[blockIndex];
+    const receivedEncoded = block instanceof BlockMessage ? block.encoded : block
+    const blockMessage = await new BlockMessage(block)
+    const hash = await blockMessage.hash()
+    const blockIndex = Number(blockMessage.decoded.index)
+    const existingBlockAtHeight = this.#blocks[blockIndex]
     if (existingBlockAtHeight) {
       if (existingBlockAtHeight.hash !== hash) {
-        console.error(`  Local:  ${existingBlockAtHeight.hash}`);
-        console.error(`  Remote: ${hash}`);
-        throw new Error(`Block conflict detected at index ${blockIndex}`);
+        console.error(`  Local:  ${existingBlockAtHeight.hash}`)
+        console.error(`  Remote: ${hash}`)
+        throw new Error(`Block conflict detected at index ${blockIndex}`)
       }
-      debug(`Block already in store: ${hash}`);
-      return;
+      debug(`Block already in store: ${hash}`)
+      return
     }
     if (blockIndex > 0) {
-      const previousBlockInfo = this.#blocks[blockIndex - 1];
+      const previousBlockInfo = this.#blocks[blockIndex - 1]
       if (!previousBlockInfo) {
-        throw new Error(`Missing parent block at index ${blockIndex - 1}`);
+        throw new Error(`Missing parent block at index ${blockIndex - 1}`)
       }
       if (previousBlockInfo.hash !== blockMessage.decoded.previousHash) {
         throw new Error(
           `previousHash mismatch at index ${blockIndex}: expected ${previousBlockInfo.hash}, got ${blockMessage.decoded.previousHash}`
-        );
+        )
       }
-    } else if (blockMessage.decoded.previousHash !== "0x0") {
-      throw new Error(`Genesis block (index 0) must have previousHash='0x0'`);
+    } else if (blockMessage.decoded.previousHash !== '0x0') {
+      throw new Error(`Genesis block (index 0) must have previousHash='0x0'`)
     }
-    const canonicalEncoded = blockMessage.encoded;
-    const byteLengthMatch = receivedEncoded.length === canonicalEncoded.length;
+    const canonicalEncoded = blockMessage.encoded
+    const byteLengthMatch = receivedEncoded.length === canonicalEncoded.length
     if (!byteLengthMatch) {
       throw new Error(
         `[FATAL] Block data size mismatch: received ${receivedEncoded.length} bytes but canonical encoding is ${canonicalEncoded.length} bytes for block #${blockMessage.decoded.index}`
-      );
+      )
     }
-    let mismatch = false;
+    let mismatch = false
     for (let i = 0; i < receivedEncoded.length; i++) {
       if (receivedEncoded[i] !== canonicalEncoded[i]) {
-        mismatch = true;
-        break;
+        mismatch = true
+        break
       }
     }
     if (mismatch) {
-      throw new Error(`[FATAL] Block data corrupted in transit for block #${blockIndex} hash ${hash}`);
+      throw new Error(`[FATAL] Block data corrupted in transit for block #${blockIndex} hash ${hash}`)
     }
-    console.log(`[chain] \u2705 Block data integrity verified: ${hash}`);
-    this.#validateBlockValidators(blockMessage);
+    console.log(`[chain] \u2705 Block data integrity verified: ${hash}`)
+    this.#validateBlockValidators(blockMessage)
     const transactions = await Promise.all(
       blockMessage.decoded.transactions.map(async (hash2) => {
-        const data = await peernet.get(hash2, "transaction");
-        await transactionPoolStore.has(hash2) && await transactionPoolStore.delete(hash2);
-        return new TransactionMessage(data);
+        const data = await peernet.get(hash2, 'transaction')
+        ;(await transactionPoolStore.has(hash2)) && (await transactionPoolStore.delete(hash2))
+        return new TransactionMessage(data)
       })
-    );
-    await globalThis.blockStore.put(hash, blockMessage.encoded);
+    )
+    await globalThis.blockStore.put(hash, blockMessage.encoded)
     this.#blocks[blockIndex] = {
       hash,
       ...blockMessage.decoded
-    };
-    debug(`added block: ${hash}`);
-    let promises = [];
-    let contracts = [];
+    }
+    debug(`added block: ${hash}`)
+    let promises = []
+    let contracts = []
     const allTransactions = transactions.sort((a, b) => {
       if (a.decoded.priority !== b.decoded.priority) {
-        return (b.decoded.priority ? 1 : 0) - (a.decoded.priority ? 1 : 0);
+        return (b.decoded.priority ? 1 : 0) - (a.decoded.priority ? 1 : 0)
       }
-      const nonceDiff = (a.decoded?.nonce ?? 0) - (b.decoded?.nonce ?? 0);
-      if (nonceDiff !== 0) return nonceDiff;
-      return 0;
-    });
-    const txsByAddress = /* @__PURE__ */ new Map();
+      const nonceDiff = (a.decoded?.nonce ?? 0) - (b.decoded?.nonce ?? 0)
+      if (nonceDiff !== 0) return nonceDiff
+      return 0
+    })
+    const txsByAddress = /* @__PURE__ */ new Map()
     for (const transaction of allTransactions) {
-      const sender = transaction.decoded.from;
+      const sender = transaction.decoded.from
       if (!txsByAddress.has(sender)) {
-        txsByAddress.set(sender, []);
+        txsByAddress.set(sender, [])
       }
-      txsByAddress.get(sender).push(transaction);
+      txsByAddress.get(sender).push(transaction)
     }
-    const addressGroups = [...txsByAddress.values()];
+    const addressGroups = [...txsByAddress.values()]
     await Promise.all(
       addressGroups.map(async (addressTxs) => {
         for (const transaction of addressTxs) {
           if (!contracts.includes(transaction.decoded.to)) {
-            contracts.push(transaction.decoded.to);
+            contracts.push(transaction.decoded.to)
           }
-          this.removePendingNonce(transaction.decoded.from, transaction.decoded.nonce);
-          await this.#handleTransaction(transaction, []);
+          this.removePendingNonce(transaction.decoded.from, transaction.decoded.nonce)
+          await this.#handleTransaction(transaction, [])
         }
       })
-    );
+    )
     try {
-      promises = await Promise.allSettled(promises);
-      const noncesByAddress = {};
+      promises = await Promise.allSettled(promises)
+      const noncesByAddress = {}
       for (let transaction of transactions) {
-        globalThis.pubsub.publish("transaction-processed", transaction.encoded);
+        globalThis.pubsub.publish('transaction-processed', transaction.encoded)
         if (transaction.decoded.to === globalThis.peernet.selectedAccount)
-          globalThis.pubsub.publish("account-transaction-processed", transaction.encoded);
-        if (!noncesByAddress[transaction.decoded.from] || noncesByAddress?.[transaction.decoded.from] < transaction.decoded.nonce) {
-          noncesByAddress[transaction.decoded.from] = transaction.decoded.nonce;
+          globalThis.pubsub.publish('account-transaction-processed', transaction.encoded)
+        if (
+          !noncesByAddress[transaction.decoded.from] ||
+          noncesByAddress?.[transaction.decoded.from] < transaction.decoded.nonce
+        ) {
+          noncesByAddress[transaction.decoded.from] = transaction.decoded.nonce
         }
       }
       await Promise.all(
         Object.entries(noncesByAddress).map(([from, nonce]) => globalThis.accountsStore.put(from, String(nonce)))
-      );
+      )
       if ((await this.lastBlock).index < Number(blockMessage.decoded.index)) {
-        await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() });
+        await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() })
         try {
-          await this.call(addresses.validators, "recordValidatorSnapshot", [blockMessage.decoded.index]);
+          await this.call(addresses.validators, 'recordValidatorSnapshot', [blockMessage.decoded.index])
         } catch (snapshotError) {
-          debug(`failed to record validator snapshot: ${snapshotError?.message ?? snapshotError}`);
+          debug(`failed to record validator snapshot: ${snapshotError?.message ?? snapshotError}`)
         }
-        await this.#handleEpochBoundary(Number(blockMessage.decoded.index));
-        await this.updateState(blockMessage);
+        await this.#handleEpochBoundary(Number(blockMessage.decoded.index))
+        await this.updateState(blockMessage)
       }
-      globalThis.pubsub.publish("block-processed", blockMessage.decoded);
+      globalThis.pubsub.publish('block-processed', blockMessage.decoded)
     } catch (error) {
-      console.log(error.hash);
-      console.log("errrrr");
-      await transactionPoolStore.delete(error.hash);
+      console.log(error.hash)
+      console.log('errrrr')
+      await transactionPoolStore.delete(error.hash)
     }
   }
   async participate(address) {
-    this.#participating = true;
+    this.#participating = true
     try {
-      if (!await this.staticCall(addresses.validators, "has", [address])) {
+      if (!(await this.staticCall(addresses.validators, 'has', [address]))) {
         const rawTransaction = {
           from: address,
           to: addresses.validators,
-          method: "addValidator",
+          method: 'addValidator',
           params: [address],
-          nonce: await this.getNonce(address) + 1,
+          nonce: (await this.getNonce(address)) + 1,
           timestamp: Date.now()
-        };
-        const transaction = await signTransaction(rawTransaction, globalThis.peernet.identity);
+        }
+        const transaction = await signTransaction(rawTransaction, globalThis.peernet.identity)
         try {
-          await this.sendTransaction(transaction);
+          await this.sendTransaction(transaction)
         } catch (error) {
-          console.error(error);
+          console.error(error)
         }
       }
     } catch (error) {
-      debug("Error in participate:", error.message);
+      debug('Error in participate:', error.message)
     }
-    if (await this.hasTransactionToHandle() && !this.#runningEpoch && this.#participating) await this.#runEpoch();
+    if ((await this.hasTransactionToHandle()) && !this.#runningEpoch && this.#participating) await this.#runEpoch()
   }
   async #handleTransaction(transaction, latestTransactions, block) {
-    const hash = await transaction.hash();
-    const doubleTransactions = [];
-    if (latestTransactions.includes(hash) || await transactionStore.has(hash)) {
-      doubleTransactions.push(hash);
+    const hash = await transaction.hash()
+    const doubleTransactions = []
+    if (latestTransactions.includes(hash) || (await transactionStore.has(hash))) {
+      doubleTransactions.push(hash)
     }
     if (doubleTransactions.length > 0) {
-      await globalThis.transactionPoolStore.delete(hash);
-      await globalThis.peernet.publish("invalid-transaction", hash);
-      return;
+      await globalThis.transactionPoolStore.delete(hash)
+      await globalThis.peernet.publish('invalid-transaction', hash)
+      return
     }
     try {
-      const result = await this.#executeTransaction({ ...transaction.decoded, hash });
+      const result = await this.#executeTransaction({ ...transaction.decoded, hash })
       if (block) {
-        block.transactions.push(hash);
-        block.fees = block.fees += await calculateFee(transaction.decoded);
+        block.transactions.push(hash)
+        block.fees = block.fees += await calculateFee(transaction.decoded)
       }
       await globalThis.accountsStore.put(
         transaction.decoded.from,
         new TextEncoder().encode(String(transaction.decoded.nonce))
-      );
-      await transactionStore.put(hash, await transaction.encode());
+      )
+      await transactionStore.put(hash, await transaction.encode())
     } catch (e) {
-      console.log("vvvvvv");
-      console.log({ e });
-      console.log(hash);
-      peernet.publish("invalid-transaction", hash);
-      await globalThis.transactionPoolStore.delete(e.hash);
+      console.log('vvvvvv')
+      console.log({ e })
+      console.log(hash)
+      peernet.publish('invalid-transaction', hash)
+      await globalThis.transactionPoolStore.delete(e.hash)
     }
   }
   // todo filter tx that need to wait on prev nonce
   async #createBlock(limit = this.transactionLimit) {
-    console.log(await globalThis.transactionPoolStore.size());
-    if (await globalThis.transactionPoolStore.size() === 0) return;
-    let transactions = await globalThis.transactionPoolStore.values(this.transactionLimit);
-    if (Object.keys(transactions)?.length === 0) return;
-    const timestamp = Date.now();
+    console.log(await globalThis.transactionPoolStore.size())
+    if ((await globalThis.transactionPoolStore.size()) === 0) return
+    let transactions = await globalThis.transactionPoolStore.values(this.transactionLimit)
+    if (Object.keys(transactions)?.length === 0) return
+    const timestamp = Date.now()
     let block = {
       transactions: [],
       validators: [],
       fees: BigInt(0),
       timestamp,
-      previousHash: "",
+      previousHash: '',
       reward: BigInt(150),
       index: 0,
-      producer: "",
-      producerProof: "",
+      producer: '',
+      producerProof: '',
       protocolVersion: this.version
-    };
-    const latestTransactions = await this.machine.latestTransactions();
-    transactions = await this.promiseTransactions(transactions);
+    }
+    const latestTransactions = await this.machine.latestTransactions()
+    transactions = await this.promiseTransactions(transactions)
     const allTransactions = transactions.sort((a, b) => {
       if (a.decoded.priority !== b.decoded.priority) {
-        return (b.decoded.priority ? 1 : 0) - (a.decoded.priority ? 1 : 0);
+        return (b.decoded.priority ? 1 : 0) - (a.decoded.priority ? 1 : 0)
       }
-      const nonceDiff = (a.decoded?.nonce ?? 0) - (b.decoded?.nonce ?? 0);
-      if (nonceDiff !== 0) return nonceDiff;
-      return 0;
-    });
-    const txsByAddress = /* @__PURE__ */ new Map();
+      const nonceDiff = (a.decoded?.nonce ?? 0) - (b.decoded?.nonce ?? 0)
+      if (nonceDiff !== 0) return nonceDiff
+      return 0
+    })
+    const txsByAddress = /* @__PURE__ */ new Map()
     for (const transaction of allTransactions) {
-      const sender = transaction.decoded.from;
+      const sender = transaction.decoded.from
       if (!txsByAddress.has(sender)) {
-        txsByAddress.set(sender, []);
+        txsByAddress.set(sender, [])
       }
-      txsByAddress.get(sender).push(transaction);
+      txsByAddress.get(sender).push(transaction)
     }
-    const addressGroups = [...txsByAddress.values()];
+    const addressGroups = [...txsByAddress.values()]
     await Promise.all(
       addressGroups.map(async (addressTxs) => {
         for (const transaction of addressTxs) {
-          await this.#handleTransaction(transaction, latestTransactions, block);
+          await this.#handleTransaction(transaction, latestTransactions, block)
         }
       })
-    );
-    if (block.transactions.length === 0) return;
-    const validators = await this.staticCall(addresses.validators, "validators");
-    const peers = {};
+    )
+    if (block.transactions.length === 0) return
+    const validators = await this.staticCall(addresses.validators, 'validators')
+    const peers = {}
     for (const entry of globalThis.peernet.peers) {
-      peers[entry[0]] = entry[1];
+      peers[entry[0]] = entry[1]
     }
     const finalizeBWAndBroadcast = async () => {
       const bwPromises = validators.map(async (validator) => {
-        const peer = peers[validator];
+        const peer = peers[validator]
         if (peer && peer.connected && this.isVersionCompatible(peer.version)) {
           try {
-            let data = await new BWRequestMessage();
-            const node = await globalThis.peernet.prepareMessage(data.encoded);
-            const bw = await peer.request(node.encoded);
+            let data = await new BWRequestMessage()
+            const node = await globalThis.peernet.prepareMessage(data.encoded)
+            const bw = await peer.request(node.encoded)
             return {
               address: validator,
               bw: bw.up + bw.down
-            };
+            }
           } catch (error) {
-            const peerId = peer?.peerId || peer?.id || peer?.address || "unknown";
-            debug(`bw request failed: ${peerId}:`, error?.message ?? error);
-            return null;
+            const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown'
+            debug(`bw request failed: ${peerId}:`, error?.message ?? error)
+            return null
           }
         } else if (globalThis.peernet.selectedAccount === validator) {
           return {
             address: globalThis.peernet.selectedAccount,
             bw: globalThis.peernet.bw.up + globalThis.peernet.bw.down
-          };
+          }
         }
-        return null;
-      });
-      const bwResults = await Promise.allSettled(bwPromises);
+        return null
+      })
+      const bwResults = await Promise.allSettled(bwPromises)
       for (const result of bwResults) {
-        if (result.status === "fulfilled" && result.value) {
-          block.validators.push(result.value);
+        if (result.status === 'fulfilled' && result.value) {
+          block.validators.push(result.value)
         }
       }
-    };
+    }
     finalizeBWAndBroadcast().catch((error) => {
-      debug(`background BW finalization failed:`, error?.message ?? error);
-    });
+      debug(`background BW finalization failed:`, error?.message ?? error)
+    })
     block.validators = block.validators.map((validator) => {
-      validator.reward = block.fees;
-      validator.reward += block.reward;
-      validator.reward /= BigInt(block.validators.length);
-      delete validator.bw;
-      return validator;
-    });
-    const localBlock = await this.lastBlock;
-    block.index = localBlock.index;
-    if (block.index === void 0) block.index = 0;
-    else block.index += 1;
-    block.previousHash = localBlock.hash || "0x0";
-    const canonicalValidators = await this.staticCall(addresses.validators, "validators");
-    const sortedValidators = [...canonicalValidators].sort();
+      validator.reward = block.fees
+      validator.reward += block.reward
+      validator.reward /= BigInt(block.validators.length)
+      delete validator.bw
+      return validator
+    })
+    const localBlock = await this.lastBlock
+    block.index = localBlock.index
+    if (block.index === void 0) block.index = 0
+    else block.index += 1
+    block.previousHash = localBlock.hash || '0x0'
+    const canonicalValidators = await this.staticCall(addresses.validators, 'validators')
+    const sortedValidators = [...canonicalValidators].sort()
     block.validators = sortedValidators.map((validatorAddress) => ({
       address: validatorAddress,
       reward: block.fees / BigInt(sortedValidators.length) + block.reward / BigInt(sortedValidators.length)
-    }));
+    }))
     try {
       await Promise.all(
         block.transactions.map(async (transaction) => {
-          await globalThis.transactionStore.put(transaction, await transactionPoolStore.get(transaction));
-          await globalThis.transactionPoolStore.delete(transaction);
+          await globalThis.transactionStore.put(transaction, await transactionPoolStore.get(transaction))
+          await globalThis.transactionPoolStore.delete(transaction)
         })
-      );
-      block.producer = globalThis.peernet.selectedAccount || "";
-      const producerSigner = globalThis.peernet?.identity;
+      )
+      block.producer = globalThis.peernet.selectedAccount || ''
+      const producerSigner = globalThis.peernet?.identity
       if (block.producer && producerSigner) {
-        const unsignedBlockMessage = await new BlockMessage({ ...block, producerProof: "" });
-        const unsignedBlockHash = await unsignedBlockMessage.hash();
+        const unsignedBlockMessage = await new BlockMessage({ ...block, producerProof: '' })
+        const unsignedBlockHash = await unsignedBlockMessage.hash()
         const signedProof = await signTransaction(
           {
             from: block.producer,
             to: addresses.validators,
-            method: "produceBlock",
+            method: 'produceBlock',
             params: [unsignedBlockHash],
             timestamp: block.timestamp
           },
           producerSigner
-        );
-        block.producerProof = signedProof.signature;
-      }
-      let blockMessage = await new BlockMessage(block);
-      const hash = await blockMessage.hash();
-      await globalThis.peernet.put(hash, blockMessage.encoded, "block");
-      await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() });
-      await this.updateState(blockMessage);
-      debug(`created block: ${hash} @${block.index}`);
-      console.log(`[consensus] \u{1F4E4} Proposing block #${block.index} | hash: ${hash} | round: ${this.#consensusRound}`);
+        )
+        block.producerProof = signedProof.signature
+      }
+      let blockMessage = await new BlockMessage(block)
+      const hash = await blockMessage.hash()
+      await globalThis.peernet.put(hash, blockMessage.encoded, 'block')
+      await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() })
+      await this.updateState(blockMessage)
+      debug(`created block: ${hash} @${block.index}`)
+      console.log(
+        `[consensus] \u{1F4E4} Proposing block #${block.index} | hash: ${hash} | round: ${this.#consensusRound}`
+      )
       const proposalData = {
         blockHash: hash,
         index: BigInt(block.index),
         round: BigInt(this.#consensusRound),
         from: peernet.selectedAccount
-      };
-      const proposalMessage = new ProposalMessage(proposalData);
-      const proposalPayload = proposalMessage.encoded;
+      }
+      const proposalMessage = new ProposalMessage(proposalData)
+      const proposalPayload = proposalMessage.encoded
       try {
-        globalThis.peernet.publish("consensus:propose", proposalPayload);
+        globalThis.peernet.publish('consensus:propose', proposalPayload)
       } catch (publishError) {
-        debug("peernet publish failed: consensus:propose", publishError?.message ?? publishError);
+        debug('peernet publish failed: consensus:propose', publishError?.message ?? publishError)
       }
-      await this.#castVote("prevote", hash, block.index, this.#consensusRound);
+      await this.#castVote('prevote', hash, block.index, this.#consensusRound)
     } catch (error) {
-      console.log(error);
-      throw new Error(`invalid block ${block}`);
+      console.log(error)
+      throw new Error(`invalid block ${block}`)
     }
   }
   async #sendTransaction(transaction) {
-    transaction = await new TransactionMessage(transaction.encoded || transaction);
-    const hash = await transaction.hash();
+    transaction = await new TransactionMessage(transaction.encoded || transaction)
+    const hash = await transaction.hash()
     try {
-      const has = await globalThis.transactionPoolStore.has(hash);
-      if (!has && !await transactionStore.has(hash)) {
-        await globalThis.transactionPoolStore.put(hash, transaction.encoded);
+      const has = await globalThis.transactionPoolStore.has(hash)
+      if (!has && !(await transactionStore.has(hash))) {
+        await globalThis.transactionPoolStore.put(hash, transaction.encoded)
       }
-      if (this.#participating && !this.#runningEpoch) this.#runEpoch();
+      if (this.#participating && !this.#runningEpoch) this.#runEpoch()
     } catch (e) {
       try {
-        globalThis.peernet.publish("invalid-transaction", hash);
+        globalThis.peernet.publish('invalid-transaction', hash)
       } catch (publishError) {
-        debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
+        debug('peernet publish failed: invalid-transaction', publishError?.message ?? publishError)
       }
-      throw new Error("invalid transaction");
+      throw new Error('invalid transaction')
     }
   }
   /**
@@ -3190,23 +3262,23 @@ class Chain extends VersionControl {
    * error is thrown on error so undefined data doesn't mean there is an error...
    **/
   async sendTransaction(transaction) {
-    const transactionMessage = await new TransactionMessage({ ...transaction });
-    const event = await super.sendTransaction(transactionMessage);
-    this.#sendTransaction(transactionMessage.encoded);
+    const transactionMessage = await new TransactionMessage({ ...transaction })
+    const event = await super.sendTransaction(transactionMessage)
+    this.#sendTransaction(transactionMessage.encoded)
     try {
-      globalThis.peernet.publish("send-transaction", transactionMessage.encoded);
+      globalThis.peernet.publish('send-transaction', transactionMessage.encoded)
     } catch (publishError) {
-      debug("peernet publish failed: send-transaction", publishError?.message ?? publishError);
+      debug('peernet publish failed: send-transaction', publishError?.message ?? publishError)
     }
-    return event;
+    return event
   }
   async addContract(transaction, contractMessage) {
-    const hash = await contractMessage.hash();
-    const has = await this.staticCall(addresses.contractFactory, "isRegistered", [hash]);
-    if (has) throw new Error("contract exists");
-    const tx = await this.sendTransaction(transaction);
-    await tx.wait;
-    return tx;
+    const hash = await contractMessage.hash()
+    const has = await this.staticCall(addresses.contractFactory, 'isRegistered', [hash])
+    if (has) throw new Error('contract exists')
+    const tx = await this.sendTransaction(transaction)
+    await tx.wait
+    return tx
   }
   /**
    *
@@ -3219,7 +3291,7 @@ class Chain extends VersionControl {
       sender,
       call: this.call,
       staticCall: this.staticCall
-    };
+    }
   }
   /**
    *
@@ -3230,7 +3302,7 @@ class Chain extends VersionControl {
    * @returns
    */
   internalCall(sender, contract, method, parameters) {
-    return this.machine.execute(contract, method, parameters);
+    return this.machine.execute(contract, method, parameters)
   }
   /**
    *
@@ -3240,31 +3312,31 @@ class Chain extends VersionControl {
    * @returns
    */
   call(contract, method, parameters) {
-    return this.machine.execute(contract, method, parameters);
+    return this.machine.execute(contract, method, parameters)
   }
   staticCall(contract, method, parameters) {
-    return this.machine.get(contract, method, parameters);
+    return this.machine.get(contract, method, parameters)
   }
   mint(to, amount) {
-    return this.call(addresses.nativeToken, "mint", [to, amount]);
+    return this.call(addresses.nativeToken, 'mint', [to, amount])
   }
   transfer(from, to, amount) {
-    return this.call(addresses.nativeToken, "transfer", [from, to, amount]);
+    return this.call(addresses.nativeToken, 'transfer', [from, to, amount])
   }
   balanceOf(address) {
-    return this.staticCall(addresses.nativeToken, "balanceOf", [address]);
+    return this.staticCall(addresses.nativeToken, 'balanceOf', [address])
   }
   get balance() {
-    return this.staticCall(addresses.nativeToken, "balanceOf", [globalThis.peernet.selectedAccount]);
+    return this.staticCall(addresses.nativeToken, 'balanceOf', [globalThis.peernet.selectedAccount])
   }
   get balances() {
-    return this.staticCall(addresses.nativeToken, "balances");
+    return this.staticCall(addresses.nativeToken, 'balances')
   }
   get contracts() {
-    return this.staticCall(addresses.contractFactory, "contracts");
+    return this.staticCall(addresses.contractFactory, 'contracts')
   }
   deleteAll() {
-    return this.machine.deleteAll();
+    return this.machine.deleteAll()
   }
   /**
    * lookup an address for a registered name using the builtin nameService
@@ -3276,27 +3348,27 @@ class Chain extends VersionControl {
    * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
    */
   lookup(name) {
-    return this.call(addresses.nameService, "lookup", [name]);
+    return this.call(addresses.nameService, 'lookup', [name])
   }
   #monitorPeerConnections() {
     setInterval(() => {
-      const connectedPeers = Object.values(globalThis.peernet.connections).filter((peer) => peer.connected);
-      debug(`Connected peers: ${connectedPeers.length}`);
+      const connectedPeers = Object.values(globalThis.peernet.connections).filter((peer) => peer.connected)
+      debug(`Connected peers: ${connectedPeers.length}`)
       if (connectedPeers.length === 0) {
-        debug("No peers connected, attempting to reconnect...");
-        this.#attemptPeerReconnection();
+        debug('No peers connected, attempting to reconnect...')
+        this.#attemptPeerReconnection()
       }
-    }, 1e4);
+    }, 1e4)
   }
   async #attemptPeerReconnection() {
     try {
       if (globalThis.peernet && globalThis.peernet.start) {
-        await globalThis.peernet.start();
+        await globalThis.peernet.start()
       }
     } catch (error) {
-      console.warn("Failed to reconnect to peers:", error.message);
+      console.warn('Failed to reconnect to peers:', error.message)
     }
   }
 }
 
-export { Chain as default };
+export { Chain as default }