@leofcoin/chain 1.9.18 → 1.9.20

package/exports/chain.js

@@ -1,89 +1,64 @@
-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;
   }
   /**
    *
@@ -92,23 +67,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);
+    });
   }
   /**
    *
@@ -116,8 +91,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;
   }
   /**
    *
@@ -127,13 +102,12 @@ 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
@@ -141,32 +115,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
@@ -175,126 +149,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
@@ -304,13 +278,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
@@ -320,10 +294,9 @@ 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
@@ -332,11 +305,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
@@ -344,7 +317,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)
@@ -352,7 +325,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)
@@ -360,7 +333,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
@@ -368,7 +341,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
@@ -376,27 +349,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
@@ -404,7 +377,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
@@ -412,7 +385,7 @@ class ContractRegistry {
    * @returns Inheritance information
    */
   analyzeContract(contractCode) {
-    return parseContractInheritance(contractCode)
+    return parseContractInheritance(contractCode);
   }
   /**
    * Build a complete contract by combining base contracts
@@ -421,35 +394,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
@@ -458,16 +431,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);
   }
   /**
    *
@@ -477,7 +450,7 @@ class Contract extends Transaction {
    * @returns lib.createContractMessage
    */
   async createContractMessage(creator, contract, constructorParameters = []) {
-    return createContractMessage(creator, contract, constructorParameters)
+    return createContractMessage(creator, contract, constructorParameters);
   }
   /**
    *
@@ -487,8 +460,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();
   }
   /**
    *
@@ -497,8 +470,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
@@ -509,15 +482,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
@@ -529,38 +502,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
@@ -569,7 +542,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
@@ -577,25 +550,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: {
@@ -609,159 +582,156 @@ 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,
@@ -779,53 +749,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),
@@ -836,13 +806,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,
@@ -852,31 +822,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
         }
-      })
-    })
+      });
+    });
   }
   /**
    *
@@ -887,40 +857,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,
@@ -928,764 +898,753 @@ ${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;
     }
   }
   /**
@@ -1693,518 +1652,515 @@ 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()
-      }
+        console.log("\u{1F514} Process resumed (SIGCONT) \u2014 attempting restore");
+        void this.#restoreNetwork();
+      };
       try {
-        process.on('SIGCONT', this.#onSigcont)
-      } catch (e) {}
+        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
@@ -2212,76 +2168,72 @@ 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
@@ -2289,252 +2241,250 @@ 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 = [
@@ -2554,706 +2504,704 @@ 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)
-      if (response === undefined || response === null) return response
+      let response = await peer.request(node.encoded);
+      console.log(`raw response for request ${request}:`, response);
+      if (response === void 0 || 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 (payload === void 0 || 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 ("response" in payload) {
+            return normalizeResponse(payload.response);
           }
         }
-        if (payload instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(payload))) {
-          return payload instanceof Uint8Array ? payload : new Uint8Array(payload)
+        if (payload instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(payload)) {
+          const bytes = payload instanceof Uint8Array ? payload : new Uint8Array(payload);
+          try {
+            const wrapped = await new globalThis.peernet.protos["peernet-response"](bytes);
+            if (wrapped?.decoded?.response !== void 0) {
+              return wrapped.decoded.response;
+            }
+          } catch {
+          }
+          try {
+            return JSON.parse(new TextDecoder().decode(bytes));
+          } catch {
+            return bytes;
+          }
         }
-        if (typeof payload === 'string') {
+        if (typeof payload === "string") {
           try {
-            return JSON.parse(payload)
+            return JSON.parse(payload);
           } catch {
-            return payload
+            return payload;
           }
         }
-        return payload
-      }
-      return await normalizeResponse(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");
+    console.log("raw response for request transactionPool:", transactionsInPool);
     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)
-      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
+      console.log("requesting last block from peer...");
+      console.log(await this.lastBlock);
+      const lastBlockRaw = await this.#makeRequest(peer, "lastBlock");
+      console.log("raw last block response:", lastBlockRaw);
+      if (lastBlockRaw === void 0 || lastBlockRaw === null || typeof lastBlockRaw !== "object" && !(lastBlockRaw instanceof Uint8Array)) {
+        throw new Error(`invalid lastBlock payload: ${typeof 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");
     }
   }
   /**
@@ -3262,23 +3210,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;
   }
   /**
    *
@@ -3291,7 +3239,7 @@ class Chain extends VersionControl {
       sender,
       call: this.call,
       staticCall: this.staticCall
-    }
+    };
   }
   /**
    *
@@ -3302,7 +3250,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);
   }
   /**
    *
@@ -3312,31 +3260,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
@@ -3348,27 +3296,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 };