@leofcoin/chain 1.10.21 → 1.11.0

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 };

package/exports/node.js

@@ -1,8 +1,33 @@
+import { BinaryFormat } from '@leofcoin/messages';
 import Peernet from '@leofcoin/peernet';
 import nodeConfig from '@leofcoin/lib/node-config';
-import { D as DEFAULT_NODE_OPTIONS } from './constants-Dy9i9S_o.js';
-import { guardPeerMessages } from './connection-monitor.js';
+import { D as DEFAULT_NODE_OPTIONS } from './constants-BQ6f-_OT.js';
+import { g as guardPeerMessages, a as guardProviderDiscovery } from './connection-monitor-BdFLRh-J.js';
 import '@leofcoin/networks';
+import '@leofcoin/codec-format-interface';
+
+function installBinaryPeerProtocol(node) {
+  if (!node.protos) throw new Error("Peer message registry is unavailable");
+  for (const [name, Original] of Object.entries(node.protos)) {
+    const schema = { ...new Original({}).proto };
+    if (name === "peernet-response") schema.response = void 0;
+    Object.freeze(schema);
+    const byteFields = Object.keys(schema).filter((key) => schema[key] instanceof Uint8Array).map((key) => key.endsWith("?") ? key.slice(0, -1) : key);
+    node.protos[name] = class extends BinaryFormat {
+      constructor(value) {
+        if (value && typeof value === "object" && !(value instanceof Uint8Array) && !(value instanceof ArrayBuffer)) {
+          value = { ...value };
+          for (const field of byteFields) {
+            if (typeof value[field] === "string")
+              value[field] = new TextEncoder().encode(value[field]);
+          }
+        }
+        super(value, schema, { name });
+      }
+    };
+  }
+  node.binaryApplicationProtocol = 1;
+}
 
 class Node {
   #node;
@@ -11,6 +36,8 @@ class Node {
   }
   async _init(config = { autoStart: false }, password) {
     config = { ...DEFAULT_NODE_OPTIONS, ...config };
+    const autoStart = config.autoStart;
+    config = { ...config, autoStart: false };
     const backend = config.transport?.webrtc?.backend || process.env.NETPEER_SWARM_WRTC_BACKEND || "vandeurenglenn";
     if (backend === "vandeurenglenn" && !globalThis.RTCPeerConnection && !globalThis.wrtc) {
       globalThis.wrtc = await import('@vandeurenglenn/wrtc');
@@ -21,8 +48,14 @@ class Node {
       config.root = `.${network}/${networkVersion || config.networkVersion}/${config.storeNamespace}`;
     }
     this.#node = globalThis.Peernet ? await new globalThis.Peernet(config, password) : await new Peernet(config, password);
+    installBinaryPeerProtocol(this.#node);
     guardPeerMessages(this.#node);
+    guardProviderDiscovery(this.#node);
     await nodeConfig(config);
+    if (autoStart) {
+      this.#node.autoStart = true;
+      await this.#node.start();
+    }
     globalThis.pubsub.subscribe("chain:ready", async () => {
       if (!this.#node.autoStart) {
         await this.#node.start();