@leofcoin/chain 1.10.22 → 1.11.0

package/exports/{connection-monitor-h2L8vsS7.js → connection-monitor-BdFLRh-J.js}

@@ -25,7 +25,35 @@ class Protocol {
 
 const INITIAL_RECONNECT_DELAY = 5e3;
 const MAX_RECONNECT_DELAY = 3e4;
+const isChainStore = (store) => store === "block" || store === "transaction" || store === "transactionPool";
 const guardProviderDiscovery = (peernet) => {
+  const handleData = peernet.handleData.bind(peernet);
+  peernet.handleData = async (peer, id, proto) => {
+    const { hash, store: storeName } = proto.decoded;
+    if (!isChainStore(storeName)) return handleData(peer, id, proto);
+    let data = new Uint8Array();
+    try {
+      const store = globalThis[`${storeName}Store`];
+      if (store && !("private" in store && store.private) && await store.has(hash)) {
+        const bytes = await store.get(hash);
+        if (!(bytes instanceof Uint8Array) || bytes.length === 0) {
+          throw new Error("local content is unavailable");
+        }
+        data = bytes;
+      } else {
+        console.warn(`Requested content unavailable in ${storeName}: ${hash}`);
+      }
+    } catch (error) {
+      console.error(`Local chain data read failed in ${storeName}: ${hash}`, error);
+    }
+    try {
+      const response = new peernet.protos["peernet-data-response"]({ hash, data });
+      const message = await peernet.prepareMessage(response);
+      await peernet.sendMessage(peer, id, message.encoded);
+    } catch (error) {
+      console.error(`Incoming chain data response failed in ${storeName}: ${hash}`, error);
+    }
+  };
   peernet.walk = async (hash) => {
     if (!hash) throw new Error("hash expected for provider discovery");
     const request = new peernet.protos["peernet-dht"]({ hash });
@@ -42,7 +70,8 @@ const guardProviderDiscovery = (peernet) => {
             timeout = setTimeout(() => reject(new Error("provider discovery timed out")), requestTimeout);
           })
         ]);
-        const bytes = result instanceof Uint8Array ? result : new Uint8Array(Object.values(result));
+        if (!(result instanceof Uint8Array)) throw new TypeError("Peer response must be Uint8Array");
+        const bytes = result;
         if (new Codec(bytes).name !== "peernet-dht-response") throw new Error("invalid provider response codec");
         const response = new peernet.protos["peernet-dht-response"](bytes).decoded;
         if (response.hash !== hash) throw new Error("provider response hash mismatch");
@@ -68,7 +97,7 @@ const guardProviderDiscovery = (peernet) => {
   const requestData = peernet.requestData.bind(peernet);
   peernet.requestData = async (hash, store, options) => {
     const storeName = typeof store === "string" ? store : store?.name;
-    if (!["block", "transaction", "transactionPool"].includes(storeName)) {
+    if (!isChainStore(storeName)) {
       return requestData(hash, store, options);
     }
     const probe = await peernet.prepareMessage(new peernet.protos["peernet-dht"]({ hash, store: storeName }));
@@ -81,7 +110,8 @@ const guardProviderDiscovery = (peernet) => {
       try {
         const fetch = async () => {
           const availability = await peer.request(probe.encoded);
-          const probeBytes = availability instanceof Uint8Array ? availability : new Uint8Array(Object.values(availability));
+          if (!(availability instanceof Uint8Array)) throw new TypeError("Peer response must be Uint8Array");
+          const probeBytes = availability;
           if (new Codec(probeBytes).name !== "peernet-dht-response") throw new Error("invalid provider response codec");
           const provider = new peernet.protos["peernet-dht-response"](probeBytes).decoded;
           if (provider.hash !== hash || !provider.has) throw new Error("peer does not provide content in requested store");

package/exports/connection-monitor.js

@@ -1,2 +1,2 @@
 import '@leofcoin/codec-format-interface';
-export { C as default, g as guardPeerMessages, a as guardProviderDiscovery, i as isSendablePeer } from './connection-monitor-h2L8vsS7.js';
+export { C as default, g as guardPeerMessages, a as guardProviderDiscovery, i as isSendablePeer } from './connection-monitor-BdFLRh-J.js';

package/exports/{constants-Dy9i9S_o.js → constants-BQ6f-_OT.js}

@@ -1,6 +1,6 @@
 import networks from '@leofcoin/networks';
 
-const PROTOCOL_VERSION = "0.4.0";
+const PROTOCOL_VERSION = "0.5.0";
 const REACHED_ONE_ZERO_ZERO = false;
 const DEFAULT_NODE_OPTIONS = {
   autoStart: false,

package/exports/hash-format-state.js

@@ -1,4 +1,4 @@
-import { P as PROTOCOL_VERSION } from './constants-Dy9i9S_o.js';
+import { P as PROTOCOL_VERSION } from './constants-BQ6f-_OT.js';
 import '@leofcoin/networks';
 
 const assertHashFormatState = async (chainStore, stateStore) => {
@@ -7,9 +7,9 @@ const assertHashFormatState = async (chainStore, stateStore) => {
     const parsed = /^(\d+)\.(\d+)\.\d+$/.exec(version);
     const current = PROTOCOL_VERSION.split(".");
     if (parsed && parsed[1] === current[0] && parsed[2] === current[1]) return;
-    throw new Error(`stored protocol ${version} is incompatible with canonical hash protocol ${PROTOCOL_VERSION}; back up existing data and use a separate migrated data root`);
+    throw new Error(`stored protocol ${version} is incompatible with canonical hash protocol ${PROTOCOL_VERSION}; explicit ledger migration or a testnet reset is required (preserve the wallet identity)`);
   }
-  if (await chainStore.has("lastBlock") || await stateStore?.has("lastBlock")) {
+  if (await chainStore.has("lastBlock") || await chainStore.has("recoveryTarget") || await stateStore?.has("lastBlock") || await stateStore?.has("checkpoint:0") || await stateStore?.has("checkpoint:1")) {
     throw new Error("existing chainstate has no protocol version; explicit canonical hash migration required");
   }
 };

package/exports/machine.js

@@ -0,0 +1,550 @@
+import addresses, { contractFactory } from '@leofcoin/addresses';
+import { randombytes } from '@leofcoin/crypto';
+import EasyWorker from '@leofcoin/workers/binary-worker';
+import { ContractMessage } from '@leofcoin/messages';
+import { ContractDeploymentError, ExecutionError } from '@leofcoin/errors';
+import { createDebugger } from '@vandeurenglenn/debug';
+import { createChainIdentity } from '@leofcoin/lib/chain-identity';
+import { w as writeCheckpoint } from './state-checkpoint-BiQ1EXzo.js';
+import { jsonStringifyBigInt } from '@leofcoin/utils';
+
+class ReadOnlyMachine {
+  constructor(workerPath, readContract) {
+    this.workerPath = workerPath;
+    this.readContract = readContract;
+  }
+  #worker;
+  #pending = /* @__PURE__ */ new Map();
+  #tail = Promise.resolve();
+  #queued = 0;
+  #seed;
+  #cache = /* @__PURE__ */ new Map();
+  #cacheBytes = 0;
+  #closed = false;
+  read(seed, contract, method, params = [], sender = "leofcoin:read-only") {
+    if (this.#closed) return Promise.reject(new Error("Read-only machine is closed"));
+    if (typeof contract !== "string" || !contract || typeof method !== "string" || !method || ["constructor", "__proto__", "prototype"].includes(method) || !Array.isArray(params))
+      return Promise.reject(new Error("Invalid read-only contract query"));
+    if (this.#queued >= 32) return Promise.reject(new Error("Read-only query queue is full"));
+    let key;
+    try {
+      key = JSON.stringify({ contract, method, params, sender }, jsonStringifyBigInt);
+      if (new TextEncoder().encode(key).byteLength > 65536) throw new Error("Read-only query is too large");
+      params = structuredClone(params);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    this.#queued++;
+    const result = this.#tail.then(async () => {
+      if (this.#closed) throw new Error("Read-only machine is closed");
+      if (this.#seed !== seed) {
+        this.#seed = seed;
+        this.#cache.clear();
+        this.#cacheBytes = 0;
+      }
+      if (this.#cache.has(key)) return structuredClone(this.#cache.get(key).value);
+      try {
+        await this.#start();
+        const initialized = await this.#request("init", {
+          readOnly: true,
+          fromState: true,
+          blocks: [],
+          peerid: "leofcoin:read-only",
+          lastBlock: seed.lastBlock,
+          state: seed.states,
+          info: seed.info
+        });
+        if (initialized !== true) throw new Error("Worker does not support isolated contract queries");
+        const value = await this.#request("read", { contract, method, params, sender });
+        const bytes = new TextEncoder().encode(JSON.stringify(value, jsonStringifyBigInt) ?? "").byteLength;
+        if (bytes > 4 * 1024 * 1024) throw new Error("Read-only result is too large");
+        while (this.#cache.size && (this.#cache.size >= 64 || this.#cacheBytes + bytes > 4 * 1024 * 1024)) {
+          const oldest = this.#cache.keys().next().value;
+          this.#cacheBytes -= this.#cache.get(oldest).bytes;
+          this.#cache.delete(oldest);
+        }
+        this.#cache.set(key, { value: structuredClone(value), bytes });
+        this.#cacheBytes += bytes;
+        return value;
+      } catch (error) {
+        this.#stop();
+        throw error;
+      }
+    });
+    this.#tail = result.then(() => void 0, () => void 0);
+    return result.finally(() => {
+      this.#queued--;
+    });
+  }
+  async #start() {
+    if (this.#worker) return;
+    const worker = await new EasyWorker(this.workerPath, { serialization: "advanced", type: "module" });
+    if (this.#closed) {
+      worker.terminate();
+      throw new Error("Read-only machine is closed");
+    }
+    this.#worker = worker;
+    worker.onmessage(async (message) => {
+      if (this.#worker !== worker) return;
+      if (message.type === "ask") {
+        try {
+          const input = message.question === "peers" ? [] : message.question === "contract" ? await this.readContract(message.input) : void 0;
+          if (this.#worker === worker) worker.postMessage({ id: message.id, input });
+        } catch {
+          if (this.#worker === worker) worker.postMessage({ id: message.id, input: void 0 });
+        }
+        return;
+      }
+      const pending = this.#pending.get(message.id);
+      if (!pending) return;
+      if (message.type !== "response" && !["initError", "readError"].includes(message.type)) return;
+      clearTimeout(pending.timer);
+      this.#pending.delete(message.id);
+      if (message.type === "response") pending.resolve(message.value);
+      else pending.reject(new Error(message.message || "Read-only worker failed"));
+    });
+    worker.onerror(() => {
+      if (this.#worker === worker) this.#stop();
+    });
+    worker.worker?.once?.("exit", () => {
+      if (this.#worker === worker) this.#stop();
+    });
+  }
+  #request(type, input) {
+    return new Promise((resolve, reject) => {
+      const id = crypto.randomUUID();
+      const timer = setTimeout(() => this.#stop(new Error("Read-only query timed out")), 1e4);
+      this.#pending.set(id, { resolve, reject, timer });
+      try {
+        this.#worker.postMessage({ id, type, input });
+      } catch (error) {
+        this.#stop(error);
+      }
+    });
+  }
+  #stop(error = new Error("Read-only worker stopped")) {
+    const worker = this.#worker;
+    this.#worker = void 0;
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.#pending.clear();
+    worker?.terminate();
+  }
+  close() {
+    this.#closed = true;
+    this.#cache.clear();
+    this.#cacheBytes = 0;
+    this.#seed = void 0;
+    this.#stop();
+  }
+}
+
+const genesisContracts = {
+  contractFactory: addresses.contractFactory,
+  nativeToken: addresses.nativeToken,
+  nameService: addresses.nameService,
+  validators: addresses.validators
+};
+const debug = createDebugger("leofcoin/machine");
+class Machine {
+  constructor(blocks = [], checkpoint) {
+    this.states = {
+      states: {},
+      lastBlock: {
+        index: -1,
+        hash: "0x0"
+      },
+      accounts: {},
+      info: {
+        nativeCalls: BigInt(0),
+        nativeMints: BigInt(0),
+        nativeBurns: BigInt(0),
+        nativeTransfers: BigInt(0),
+        totalBurnAmount: BigInt(0),
+        totalMintAmount: BigInt(0),
+        totalTransferAmount: BigInt(0),
+        totalTransactions: BigInt(0),
+        totalBlocks: BigInt(0)
+      }
+    };
+    this.wantList = [];
+    this.ready = new Promise((resolve, reject) => {
+      this.readyResolve = resolve;
+      this.readyReject = reject;
+    });
+    this.#checkpointGeneration = -1;
+    this.#closed = false;
+    this.init(blocks, checkpoint).then(() => this.readyResolve(this), (error) => {
+      this.close();
+      this.readyReject(error);
+    });
+  }
+  #checkpointGeneration;
+  #chainId;
+  #reader;
+  #contractReader;
+  #readSnapshot;
+  #workerPath;
+  #closed;
+  close() {
+    this.#closed = true;
+    this.#reader?.close();
+    this.#contractReader?.close();
+    this.worker?.terminate();
+  }
+  async init(blocks, checkpoint) {
+    return this.#init(blocks, checkpoint);
+  }
+  async #onmessage(data) {
+    if (this.#closed) return;
+    switch (data.type) {
+      case "contractError": {
+        console.warn(data.message ?? data.error);
+        console.warn(`contract error: ${data.hash}`);
+        break;
+      }
+      case "initError": {
+        pubsub.publish(data.id, { error: new Error(`Machine initialization failed: ${data.message}`) });
+        break;
+      }
+      case "executeError": {
+        pubsub.publish(data.id, { error: data.message });
+        break;
+      }
+      case "addLoadedBlockError":
+      case "runContractError":
+      case "collectFeeError":
+      case "settleRewardsError": {
+        pubsub.publish(data.id, { error: new Error(data.message) });
+        break;
+      }
+      case "snapshotError": {
+        pubsub.publish(data.id, { error: new Error(data.message) });
+        break;
+      }
+      case "getError": {
+        pubsub.publish(data.id, { error: new 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]);
+        }
+        break;
+      }
+      case "error": {
+        console.error(data.message);
+        break;
+      }
+      case "response": {
+        pubsub.publish(data.id, data.value ?? false);
+        break;
+      }
+      case "addToWantList": {
+        if (!this.wantList.includes(data.hash)) this.wantList.push(data.hash);
+        break;
+      }
+      case "ask": {
+        if (data.question === "staticCall") {
+          try {
+            const { snapshot, contract, method, params, sender } = data.input;
+            const input = await this.#contractReader.read(snapshot, contract, method, params, sender);
+            if (!this.#closed) this.worker.postMessage({ id: data.id, input });
+          } catch (error) {
+            if (!this.#closed) this.worker.postMessage({ id: data.id, error: error instanceof Error ? error.message : String(error) });
+          }
+          break;
+        }
+        if (data.question === "contract" || data.question === "transaction") {
+          try {
+            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);
+            } else {
+              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);
+          }
+        } 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 });
+        }
+      }
+    }
+  }
+  async updateState(strict = false) {
+    try {
+      const snapshot = await this.#askWorker("snapshot");
+      snapshot.chainId = this.#chainId;
+      const accounts = {};
+      for (const address of await accountsStore.keys()) {
+        const raw = await accountsStore.get(address);
+        accounts[address] = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+      }
+      snapshot.accounts = accounts;
+      const generation = this.#checkpointGeneration + 1;
+      await writeCheckpoint(stateStore, snapshot, generation, Object.values(genesisContracts));
+      this.#checkpointGeneration = generation;
+      this.states = snapshot;
+      this.#readSnapshot = structuredClone(snapshot);
+    } catch (error) {
+      if (strict) throw error;
+      console.error(error);
+      throw error;
+    }
+  }
+  async #init(blocks, checkpoint) {
+    const identity = await createChainIdentity(globalThis.peernet?.network || "leofcoin:peach", addresses);
+    this.#chainId = identity.chainId;
+    if (checkpoint) {
+      this.#checkpointGeneration = checkpoint.generation;
+      this.states = checkpoint.snapshot;
+    }
+    let pre = "./";
+    try {
+      const { fileURLToPath } = await import('url');
+      pre = fileURLToPath(new URL(".", import.meta.url));
+    } catch {
+    }
+    this.#workerPath = pre + "workers/machine-worker.js";
+    const readContract = (hash) => globalThis.contractStore.get(hash);
+    this.#reader = new ReadOnlyMachine(this.#workerPath, readContract);
+    this.#contractReader = new ReadOnlyMachine(this.#workerPath, readContract);
+    this.worker = await new EasyWorker(this.#workerPath, {
+      serialization: "advanced",
+      type: "module"
+    });
+    if (this.#closed) {
+      this.worker.terminate();
+      throw new Error("State machine is closed");
+    }
+    this.worker.onmessage(this.#onmessage.bind(this));
+    const initialized = await this.#askWorker("init", {
+      blocks,
+      fromState: Boolean(checkpoint),
+      lastBlock: checkpoint?.snapshot.lastBlock,
+      state: checkpoint?.snapshot.states,
+      info: checkpoint?.snapshot.info,
+      peerid: peernet.peerId
+    });
+    if (initialized !== true) throw new Error("Worker does not support checkpoint initialization; deploy matching chain and worker builds");
+    this.#readSnapshot = structuredClone(checkpoint?.snapshot ?? await this.#askWorker("snapshot"));
+  }
+  async #runContract(contractMessage) {
+    const hash = await contractMessage.hash();
+    return new Promise((resolve, reject) => {
+      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);
+      this.worker.postMessage({
+        type: "run",
+        id,
+        input: {
+          decoded: contractMessage.decoded,
+          encoded: contractMessage.encoded,
+          hash
+        }
+      });
+    });
+  }
+  /**
+   *
+   * @param {Address} contract
+   * @param {String} method
+   * @param {Array} parameters
+   * @returns Promise<message>
+   */
+  async execute(contract, method, parameters, sender, execution) {
+    if (this.#closed) throw new Error("State machine is closed");
+    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 (!message) {
+          message = await globalThis.contractStore.get(parameters[0]);
+          message = await new ContractMessage(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}`);
+    }
+    return new Promise((resolve, reject) => {
+      const id = randombytes(20).toString("hex");
+      const timeout = setTimeout(() => {
+        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);
+      this.worker.postMessage({
+        type: "execute",
+        id,
+        input: {
+          to: contract,
+          contract,
+          method,
+          params: parameters,
+          sender,
+          executionSeed: execution?.seed,
+          executionTimestamp: execution?.timestamp,
+          executionRandomness: execution?.randomness
+        }
+      });
+    });
+  }
+  collectFee(from, payments, burned) {
+    return this.#askWorker("collectFee", { from, payments, burned });
+  }
+  settleRewards(rewards) {
+    return this.#askWorker("settleRewards", { rewards });
+  }
+  get(contract, method, parameters) {
+    if (!this.#readSnapshot) return Promise.reject(new Error("Contract read state is not initialized"));
+    return this.#reader.read(this.#readSnapshot, contract, method, parameters ?? []);
+  }
+  async has(address) {
+    return new Promise((resolve, reject) => {
+      const id = randombytes(20).toString("hex");
+      const timeout = setTimeout(() => {
+        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);
+      this.worker.postMessage({
+        type: "has",
+        id,
+        input: {
+          address
+        }
+      });
+    });
+  }
+  #askWorker(type, input) {
+    if (this.#closed) return Promise.reject(new Error("State machine is closed"));
+    return new Promise((resolve, reject) => {
+      const id = randombytes(20).toString("hex");
+      const timeout = setTimeout(() => {
+        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);
+      this.worker.postMessage({
+        type,
+        id,
+        input
+      });
+    });
+  }
+  get contracts() {
+    return this.#askWorker("contracts");
+  }
+  get totalContracts() {
+    return this.#askWorker("totalContracts");
+  }
+  get nativeCalls() {
+    return this.#askWorker("nativeCalls");
+  }
+  get nativeMints() {
+    return this.#askWorker("nativeMints");
+  }
+  get nativeBurns() {
+    return this.#askWorker("nativeBurns");
+  }
+  get nativeTransfers() {
+    return this.#askWorker("nativeTransfers");
+  }
+  get totalBurnAmount() {
+    return this.#askWorker("totalBurnAmount");
+  }
+  get totalMintAmount() {
+    return this.#askWorker("totalMintAmount");
+  }
+  get totalTransferAmount() {
+    return this.#askWorker("totalTransferAmount");
+  }
+  get totalTransactions() {
+    return this.#askWorker("totalTransactions");
+  }
+  get totalBlocks() {
+    return this.#askWorker("totalBlocks");
+  }
+  get blocks() {
+    return this.getBlocks();
+  }
+  get lastBlock() {
+    return Promise.resolve(this.states.lastBlock);
+  }
+  getCanonicalTip() {
+    return this.#askWorker("lastBlock");
+  }
+  get lastBlockHeight() {
+    return Promise.resolve(Number(this.states.lastBlock.index));
+  }
+  getBlocks(from, to) {
+    return this.#askWorker("blocks", { from, to });
+  }
+  getBlock(index) {
+    return this.#askWorker("block", index);
+  }
+  async addLoadedBlock(block) {
+    debug(`adding loaded block: ${block.index}@${block.hash}`);
+    if (block.decoded) block = { ...block.decoded, hash: await block.hash() };
+    return this.#askWorker("addLoadedBlock", block);
+  }
+  async latestTransactions() {
+    return this.#askWorker("latestTransactions");
+  }
+  async 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);
+  }
+}
+
+export { Machine as default };