@o1-labs/mina-archive-node-graphql 0.0.6 → 2.0.0

package/src/services/blocks-service/blocks-service.ts

@@ -10,6 +10,7 @@ import type {
   BlockSortByInput,
 } from '../../resolvers-types.js';
 import { IBlocksService } from './blocks-service.interface.js';
+import { BEST_CHAIN_TIP_HEIGHT_SQL } from '../../db/sql/best-chain.js';
 import {
   TracingState,
   extractTraceStateFromOptions,
@@ -79,7 +80,9 @@ class BlocksService implements IBlocksService {
     options: unknown
   ): Promise<Blocks> {
     const tracingState = extractTraceStateFromOptions(options);
-    return (await this.getBlockData(query, limit, sortBy, { tracingState })) ?? [];
+    return (
+      (await this.getBlockData(query, limit, sortBy, { tracingState })) ?? []
+    );
   }
 
   async getBlockData(
@@ -128,7 +131,8 @@ class BlocksService implements IBlocksService {
     const dateTimeLt = query?.dateTime_lt;
     const canonical = query?.canonical;
     const inBestChain = query?.inBestChain;
-    const orderBy = sortBy === 'BLOCKHEIGHT_DESC' ? 'DESC' : 'ASC';
+    const orderBy: 'ASC' | 'DESC' =
+      sortBy === 'BLOCKHEIGHT_DESC' ? 'DESC' : 'ASC';
     const limitValue = Math.min(limit ?? 200, BLOCK_RANGE_SIZE);
 
     // Build the SQL query for blocks with transactions
@@ -192,16 +196,15 @@ class BlocksService implements IBlocksService {
       paramIndex++;
     }
 
-    const best_chain_til_canonical_cte =
-      `
+    const best_chain_til_canonical_cte = `
         WITH RECURSIVE best_chain_til_canonical AS (
             SELECT
                 id,
                 parent_id,
                 height
             FROM blocks
-            WHERE height = (SELECT MAX(height) FROM blocks)
-            AND chain_status = 'pending'
+            WHERE chain_status = 'pending'
+            AND height = ${BEST_CHAIN_TIP_HEIGHT_SQL}
 
             UNION
 
@@ -213,19 +216,18 @@ class BlocksService implements IBlocksService {
             JOIN best_chain_til_canonical ON potential_parent.id = best_chain_til_canonical.parent_id
             WHERE potential_parent.chain_status <> 'canonical'
         )
-        `
+        `;
     if (inBestChain === true) {
       sql =
-        best_chain_til_canonical_cte
-        + sql
-        + ` AND (b.id IN (SELECT id FROM best_chain_til_canonical) OR b.chain_status = 'canonical')`;
+        best_chain_til_canonical_cte +
+        sql +
+        ` AND (b.id IN (SELECT id FROM best_chain_til_canonical) OR b.chain_status = 'canonical')`;
     } else if (inBestChain === false) {
       sql =
-        best_chain_til_canonical_cte
-        + sql
-        + ` AND (b.id NOT IN (SELECT id FROM best_chain_til_canonical)
+        best_chain_til_canonical_cte +
+        sql +
+        ` AND (b.id NOT IN (SELECT id FROM best_chain_til_canonical)
                  OR b.chain_status = 'orphaned')`;
-
     }
 
     sql += ` ORDER BY b.height ${orderBy}`;

package/src/services/network-service/network-service.ts

@@ -19,7 +19,7 @@ class NetworkService implements INetworkService {
 
   async getNetworkState(options: unknown): Promise<NetworkState> {
     const tracingState = extractTraceStateFromOptions(options);
-    return (await this.getNetworkStateData({ tracingState })) ?? [];
+    return this.getNetworkStateData({ tracingState });
   }
 
   async getNetworkStateData({
@@ -32,19 +32,37 @@ class NetworkService implements INetworkService {
     sqlSpan.end();
 
     const processingSpan = tracingState.startSpan('networkState.processing');
-    const maxBlockHeightInfo = {
-      canonicalMaxBlockHeight: Number(
-        rows.filter((row) => row.chain_status === 'canonical')[0].height
-      ),
-      pendingMaxBlockHeight: Number(
-        rows.filter((row) => row.chain_status === 'pending')[0].height
-      ),
-    };
-    const networkState = {
-      maxBlockHeight: maxBlockHeightInfo
+
+    // The SQL returns at most one row per chain_status. Either row may be
+    // missing on a fresh archive or against a static fixture, so don't
+    // assume both are present.
+    const canonicalRow = rows.find((r) => r.chain_status === 'canonical');
+    const pendingRow = rows.find((r) => r.chain_status === 'pending');
+
+    // No data at all: surface as maxBlockHeight=null. The schema allows it
+    // (NetworkStateOutput.maxBlockHeight is nullable) and it's a clearer
+    // signal to clients than fake zeroes.
+    if (!canonicalRow && !pendingRow) {
+      processingSpan.end();
+      return { maxBlockHeight: null };
     }
+
+    // canonical ≤ pending by definition. When one side is missing, fall back
+    // so the schema's non-null Int! contract is honored without lying:
+    //   - missing canonical → 0 (no block has been finalized yet)
+    //   - missing pending   → equal to canonical (archive is fully quiesced)
+    const canonicalMaxBlockHeight = canonicalRow ? Number(canonicalRow.height) : 0;
+    const pendingMaxBlockHeight = pendingRow
+      ? Number(pendingRow.height)
+      : canonicalMaxBlockHeight;
+
     processingSpan.end();
-    return networkState;
+    return {
+      maxBlockHeight: {
+        canonicalMaxBlockHeight,
+        pendingMaxBlockHeight,
+      },
+    };
   }
 
   private async executeNetworkStateQuery() {

package/src/services/verification-key-updates-service/verification-key-updates-service.interface.ts

@@ -0,0 +1,9 @@
+import type { VerificationKeyUpdates } from '../../blockchain/types.js';
+import type { VerificationKeyUpdateFilterInput } from '../../resolvers-types.js';
+
+export interface IVerificationKeyUpdatesService {
+  getVerificationKeyUpdates(
+    input: VerificationKeyUpdateFilterInput,
+    options: unknown
+  ): Promise<VerificationKeyUpdates>;
+}

package/src/services/verification-key-updates-service/verification-key-updates-service.ts

@@ -0,0 +1,72 @@
+import type postgres from 'postgres';
+import { BlockStatusFilter } from '../../blockchain/types.js';
+import type { VerificationKeyUpdates } from '../../blockchain/types.js';
+import {
+  createBlockInfo,
+  createTransactionInfo,
+} from '../../blockchain/utils.js';
+import { throwBlockRangeError } from '../../errors/error.js';
+import type { VerificationKeyUpdateFilterInput } from '../../resolvers-types.js';
+import { BLOCK_RANGE_SIZE } from '../../server/server.js';
+import {
+  extractTraceStateFromOptions,
+  TracingState,
+} from '../../tracing/tracer.js';
+import { getVerificationKeyUpdatesQuery } from '../../db/sql/verification-key-updates/queries.js';
+import type { IVerificationKeyUpdatesService } from './verification-key-updates-service.interface.js';
+
+export class VerificationKeyUpdatesService
+  implements IVerificationKeyUpdatesService
+{
+  constructor(private readonly client: postgres.Sql) {}
+
+  async getVerificationKeyUpdates(
+    input: VerificationKeyUpdateFilterInput,
+    options: unknown
+  ): Promise<VerificationKeyUpdates> {
+    const tracingState = extractTraceStateFromOptions(options);
+    return this.getVerificationKeyUpdateData(input, { tracingState });
+  }
+
+  async getVerificationKeyUpdateData(
+    input: VerificationKeyUpdateFilterInput,
+    { tracingState }: { tracingState: TracingState }
+  ): Promise<VerificationKeyUpdates> {
+    this.validateRange(input.from, input.to);
+
+    const sqlSpan = tracingState.startSpan('verificationKeyUpdates.SQL');
+    const rows = await getVerificationKeyUpdatesQuery(
+      this.client,
+      input.verificationKeyHash,
+      input.from,
+      input.to,
+      input.status ?? BlockStatusFilter.all
+    );
+    sqlSpan.end();
+
+    const processingSpan = tracingState.startSpan(
+      'verificationKeyUpdates.processing'
+    );
+    const updates = rows.map((row) => ({
+      accountUpdateId: row.account_update_id.toString(),
+      address: row.address,
+      tokenId: row.token_id,
+      verificationKeyHash: row.verification_key_hash,
+      blockInfo: createBlockInfo(row),
+      transactionInfo: createTransactionInfo(row),
+    }));
+    processingSpan.end();
+    return updates;
+  }
+
+  private validateRange(from: number, to: number) {
+    if (to <= from) {
+      throwBlockRangeError('to must be greater than from');
+    }
+    if (to - from > BLOCK_RANGE_SIZE) {
+      throwBlockRangeError(
+        `The block range is too large. The maximum range is ${BLOCK_RANGE_SIZE}`
+      );
+    }
+  }
+}

package/src/services/zkapp-commands-service/zkapp-commands-service.interface.ts

@@ -0,0 +1,9 @@
+import type { ZkappCommands } from '../../blockchain/types.js';
+import type { ZkappCommandFilterOptionsInput } from '../../resolvers-types.js';
+
+export interface IZkappCommandsService {
+  getZkappCommands(
+    input: ZkappCommandFilterOptionsInput,
+    options: unknown
+  ): Promise<ZkappCommands>;
+}

package/src/services/zkapp-commands-service/zkapp-commands-service.ts

@@ -0,0 +1,181 @@
+import type postgres from 'postgres';
+import {
+  BlockStatusFilter,
+  type BlockInfo,
+  type ZkappCommand,
+  type ZkappCommands,
+} from '../../blockchain/types.js';
+import type { ZkappCommandFilterOptionsInput } from '../../resolvers-types.js';
+import {
+  getZkappCommandAccountUpdateCountQuery,
+  getZkappCommandsQuery,
+} from '../../db/sql/zkapp-commands/queries.js';
+import type { ZkappCommandDatabaseRow } from '../../db/sql/zkapp-commands/types.js';
+import {
+  TracingState,
+  extractTraceStateFromOptions,
+} from '../../tracing/tracer.js';
+import {
+  ZKAPP_COMMAND_ACCOUNT_UPDATE_LIMIT,
+  ZKAPP_COMMAND_RANGE_SIZE,
+} from '../../server/server.js';
+import { throwBlockRangeError } from '../../errors/error.js';
+import type { IZkappCommandsService } from './zkapp-commands-service.interface.js';
+
+export { ZkappCommandsService };
+export { normalizeZkappCommandRange };
+export { assertZkappCommandAccountUpdateLimit };
+
+function normalizeZkappCommandRange(input: ZkappCommandFilterOptionsInput): {
+  from: number;
+  to: number;
+} {
+  const { from, to } = input;
+
+  if (from === null || from === undefined || to === null || to === undefined) {
+    throwBlockRangeError('from and to are required');
+  }
+  if (to <= from) {
+    throwBlockRangeError('to must be greater than from');
+  }
+  if (to - from > ZKAPP_COMMAND_RANGE_SIZE) {
+    throwBlockRangeError(
+      `The zkApp command block range is too large. The maximum range is ${ZKAPP_COMMAND_RANGE_SIZE}`
+    );
+  }
+
+  return { from, to };
+}
+
+function assertZkappCommandAccountUpdateLimit(accountUpdateCount: number) {
+  if (accountUpdateCount > ZKAPP_COMMAND_ACCOUNT_UPDATE_LIMIT) {
+    throwBlockRangeError(
+      `The zkApp command range expands to ${accountUpdateCount} account updates. The maximum is ${ZKAPP_COMMAND_ACCOUNT_UPDATE_LIMIT}; use a smaller block range.`
+    );
+  }
+}
+
+class ZkappCommandsService implements IZkappCommandsService {
+  private readonly client: postgres.Sql;
+
+  constructor(client: postgres.Sql) {
+    this.client = client;
+  }
+
+  async getZkappCommands(
+    input: ZkappCommandFilterOptionsInput,
+    options: unknown
+  ): Promise<ZkappCommands> {
+    const tracingState = extractTraceStateFromOptions(options);
+    return (await this.getZkappCommandData(input, { tracingState })) ?? [];
+  }
+
+  async getZkappCommandData(
+    input: ZkappCommandFilterOptionsInput,
+    { tracingState }: { tracingState: TracingState }
+  ): Promise<ZkappCommands> {
+    const sqlSpan = tracingState.startSpan('zkappCommands.SQL');
+    const rows = await this.executeZkappCommandsQuery(input);
+    sqlSpan.end();
+
+    const processingSpan = tracingState.startSpan('zkappCommands.processing');
+    const commands = this.rowsToZkappCommands(rows);
+    processingSpan.end();
+    return commands;
+  }
+
+  private async executeZkappCommandsQuery(
+    input: ZkappCommandFilterOptionsInput
+  ) {
+    const { accountPublicKey, tokenId } = input;
+    let { blockStatus } = input;
+    const range = normalizeZkappCommandRange(input);
+
+    blockStatus ||= BlockStatusFilter.all;
+    const [{ count }] = await getZkappCommandAccountUpdateCountQuery(
+      this.client,
+      blockStatus,
+      range.to,
+      range.from,
+      accountPublicKey?.toString(),
+      tokenId?.toString()
+    );
+    assertZkappCommandAccountUpdateLimit(Number(count));
+
+    return getZkappCommandsQuery(
+      this.client,
+      blockStatus,
+      range.to,
+      range.from,
+      accountPublicKey?.toString(),
+      tokenId?.toString()
+    );
+  }
+
+  rowsToZkappCommands(rows: ZkappCommandDatabaseRow[]): ZkappCommands {
+    const commandsByKey = new Map<string, ZkappCommand>();
+
+    for (const row of rows) {
+      const commandKey = `${row.state_hash}:${row.sequence_number}:${row.hash}`;
+      let command = commandsByKey.get(commandKey);
+      if (!command) {
+        command = this.createZkappCommand(row);
+        commandsByKey.set(commandKey, command);
+      }
+
+      command.accountUpdates.push({
+        id: row.account_update_id.toString(),
+        publicKey: row.public_key,
+        tokenId: row.token_id,
+        authorizationKind: row.authorization_kind,
+        balanceChange: row.balance_change,
+        incrementNonce: row.increment_nonce,
+        callDepth: row.call_depth,
+        actions: row.actions,
+        events: row.events,
+        appState: row.app_state,
+        accountPrecondition: {
+          state: row.account_precondition_state,
+          actionState: row.account_precondition_action_state,
+          provedState: row.account_precondition_proved_state,
+          isNew: row.account_precondition_is_new,
+        },
+        networkPrecondition: {
+          globalSlotSinceGenesis: {
+            lowerBound: row.network_precondition_global_slot_lower_bound,
+            upperBound: row.network_precondition_global_slot_upper_bound,
+          },
+        },
+      });
+    }
+
+    return Array.from(commandsByKey.values());
+  }
+
+  private createZkappCommand(row: ZkappCommandDatabaseRow): ZkappCommand {
+    return {
+      blockInfo: this.createBlockInfo(row),
+      hash: row.hash,
+      feePayer: row.fee_payer,
+      fee: row.fee,
+      memo: row.memo,
+      sequenceNumber: row.sequence_number,
+      accountUpdates: [],
+    };
+  }
+
+  private createBlockInfo(row: ZkappCommandDatabaseRow): BlockInfo {
+    return {
+      height: Number(row.height),
+      stateHash: row.state_hash,
+      parentHash: row.parent_hash,
+      ledgerHash: row.ledger_hash,
+      chainStatus: row.chain_status,
+      timestamp: row.timestamp,
+      globalSlotSinceHardfork: Number(row.global_slot_since_hard_fork),
+      globalSlotSinceGenesis: Number(row.global_slot_since_genesis),
+      distanceFromMaxBlockHeight: Number(row.distance_from_max_block_height),
+      lastVrfOutput: row.last_vrf_output,
+    };
+  }
+}

package/src/tracing/jaeger-tracing.ts

@@ -11,6 +11,7 @@ import {
   parseEndpoint,
   checkJaegerEndpointAvailability,
 } from './jaeger-setup.js';
+import { parseBoolean } from '../config.js';
 
 export { initJaegerProvider };
 
@@ -20,7 +21,7 @@ function createJaegerExporter(endpoint: string) {
 
 async function initJaegerProvider(): Promise<BasicTracerProvider | undefined> {
   const jaegerEndpoint = process.env.JAEGER_ENDPOINT;
-  if (!process.env.ENABLE_JAEGER || !jaegerEndpoint) {
+  if (!parseBoolean(process.env.ENABLE_JAEGER) || !jaegerEndpoint) {
     return undefined;
   }
 

package/build/tests/consensus/run-compare.js

@@ -1,40 +0,0 @@
-import pwd from 'process';
-import path from 'path';
-import fs from 'fs/promises';
-const TYPESCRIPT_OUTPUT_DIR_NAME = process.env.TYPESCRIPT_OUTPUT_DIR_NAME || 'precomputed_ts';
-const OCAML_OUTPUT_DIR_NAME = process.env.OCAML_OUTPUT_DIR_NAME || 'precomputed_ocaml';
-const TYPESCRIPT_DIR = path.join(pwd.cwd(), TYPESCRIPT_OUTPUT_DIR_NAME);
-const OCAML_DIR = path.join(pwd.cwd(), OCAML_OUTPUT_DIR_NAME);
-async function compareFiles() {
-    const typescriptFiles = await fs.readdir(TYPESCRIPT_DIR);
-    const ocamlFiles = await fs.readdir(OCAML_DIR);
-    if (typescriptFiles.length !== ocamlFiles.length) {
-        console.error('Directories do not contain the same number of files!');
-        console.error(`TypeScript: ${typescriptFiles.length}`);
-        console.error(`OCaml: ${ocamlFiles.length}`);
-        return;
-    }
-    for (let i = 0; i < typescriptFiles.length; i++) {
-        const tsFile = typescriptFiles[i];
-        const ocamlFile = ocamlFiles[i];
-        if (tsFile !== ocamlFile) {
-            console.error(`File names do not match! (${tsFile} vs ${ocamlFile})`);
-            continue;
-        }
-        const tsContent = await fs.readFile(path.join(TYPESCRIPT_DIR, tsFile), 'utf-8');
-        const ocamlContent = await fs.readFile(path.join(OCAML_DIR, ocamlFile), 'utf-8');
-        const tsContentJson = JSON.parse(tsContent);
-        const ocamlContentJson = JSON.parse(ocamlContent);
-        if (tsContentJson['height'] !== ocamlContentJson['height'] ||
-            tsContentJson['previous_state_hash'] !==
-                ocamlContentJson['previous_state_hash']) {
-            console.error(`File contents do not match! (${tsFile}), (${ocamlFile}})`);
-            console.error(`TypeScript: ${JSON.stringify(tsContentJson)}`);
-            console.error(`OCaml: ${JSON.stringify(ocamlContentJson)}`);
-            return;
-        }
-    }
-    console.log('🎉 All files match!');
-}
-compareFiles();
-//# sourceMappingURL=run-compare.js.map

package/build/tests/consensus/run-compare.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-compare.js","sourceRoot":"","sources":["../../../tests/consensus/run-compare.ts"],"names":[],"mappings":"AAIA,OAAO,GAAG,MAAM,SAAS,CAAC;AAC1B,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,MAAM,aAAa,CAAC;AAE7B,MAAM,0BAA0B,GAC9B,OAAO,CAAC,GAAG,CAAC,0BAA0B,IAAI,gBAAgB,CAAC;AAC7D,MAAM,qBAAqB,GACzB,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,mBAAmB,CAAC;AAE3D,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,0BAA0B,CAAC,CAAC;AACxE,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,qBAAqB,CAAC,CAAC;AAE9D,KAAK,UAAU,YAAY;IACzB,MAAM,eAAe,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IACzD,MAAM,UAAU,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAG/C,IAAI,eAAe,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM,EAAE,CAAC;QACjD,OAAO,CAAC,KAAK,CAAC,sDAAsD,CAAC,CAAC;QACtE,OAAO,CAAC,KAAK,CAAC,eAAe,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC;QACvD,OAAO,CAAC,KAAK,CAAC,UAAU,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;QAC7C,OAAO;IACT,CAAC;IAGD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAChD,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;QAClC,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAGhC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO,CAAC,KAAK,CAAC,6BAA6B,MAAM,OAAO,SAAS,GAAG,CAAC,CAAC;YACtE,SAAS;QACX,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,EAAE,CAAC,QAAQ,CACjC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,EACjC,OAAO,CACR,CAAC;QACF,MAAM,YAAY,GAAG,MAAM,EAAE,CAAC,QAAQ,CACpC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,EAC/B,OAAO,CACR,CAAC;QAEF,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAC5C,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAGlD,IACE,aAAa,CAAC,QAAQ,CAAC,KAAK,gBAAgB,CAAC,QAAQ,CAAC;YACtD,aAAa,CAAC,qBAAqB,CAAC;gBAClC,gBAAgB,CAAC,qBAAqB,CAAC,EACzC,CAAC;YACD,OAAO,CAAC,KAAK,CAAC,gCAAgC,MAAM,OAAO,SAAS,IAAI,CAAC,CAAC;YAC1E,OAAO,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;YAC9D,OAAO,CAAC,KAAK,CAAC,UAAU,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;YAC5D,OAAO;QACT,CAAC;IACH,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AACrC,CAAC;AAED,YAAY,EAAE,CAAC"}

package/build/tests/consensus/select-consensus-precomputed.js

@@ -1,80 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { select } from '../../src/consensus/mina-consensus.js';
-import { GetSlot, } from './types.js';
-const outputDir = process.env.OUTPUT_DIR || 'precomputed_ts';
-function readPrecomputedBlocks() {
-    const directoryPath = path.join(process.cwd(), 'precomputed_berkeley');
-    const files = fs.readdirSync(directoryPath);
-    const blocks = [];
-    for (const file of files) {
-        const data = fs.readFileSync(path.join(directoryPath, file));
-        const block = mapPrecomputedToBlockInfo(data.toString());
-        blocks.push(block);
-    }
-    blocks.sort((a, b) => {
-        if (a.height < b.height)
-            return -1;
-        if (a.height > b.height)
-            return 1;
-        if (a.timestamp < b.timestamp)
-            return -1;
-        if (a.timestamp > b.timestamp)
-            return 1;
-        return 0;
-    });
-    return blocks;
-}
-function mapPrecomputedToBlockInfo(block) {
-    const json = JSON.parse(block);
-    return {
-        height: parseInt(json.data.protocol_state.body.consensus_state.blockchain_length),
-        parentHash: json.data.protocol_state.previous_state_hash,
-        ledgerHash: json.data.protocol_state.body.blockchain_state.staged_ledger_hash
-            .non_snark.ledger_hash,
-        chainStatus: '',
-        timestamp: json.data.protocol_state.body.constants.genesis_state_timestamp,
-        globalSlotSinceHardfork: GetSlot(json.data.protocol_state.body.consensus_state.curr_global_slot.slot_number),
-        globalSlotSinceGenesis: GetSlot(json.data.protocol_state.body.consensus_state.global_slot_since_genesis),
-        lastVrfOutput: json.data.protocol_state.body.consensus_state.last_vrf_output,
-        stateHash: '',
-        distanceFromMaxBlockHeight: 0,
-    };
-}
-function runSelect(candidate, currentChain) {
-    const existing = currentChain[currentChain.length - 1];
-    const newBlock = select({ blockInfo: existing }, { blockInfo: candidate });
-    if (newBlock.blockInfo.height > existing.height) {
-        currentChain.push(newBlock.blockInfo);
-        return;
-    }
-    if (newBlock.blockInfo.height === existing.height) {
-        currentChain[currentChain.length - 1] = newBlock.blockInfo;
-        return;
-    }
-}
-function writeBlocksOutput(blocks) {
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-    }
-    for (let i = 0; i < blocks.length; i++) {
-        const block = blocks[i];
-        const json = {
-            height: block.height,
-            previous_state_hash: block.parentHash,
-        };
-        fs.writeFileSync(path.join(process.cwd(), outputDir, `block_${i}.json`), JSON.stringify(json));
-    }
-}
-function main() {
-    const precomputed_blocks = readPrecomputedBlocks();
-    const [firstBlock, ...restOfPrecomputedBlocks] = precomputed_blocks;
-    const currentChain = [];
-    currentChain.push(firstBlock);
-    for (const precomputed_block of restOfPrecomputedBlocks) {
-        runSelect(precomputed_block, currentChain);
-    }
-    writeBlocksOutput(currentChain);
-}
-main();
-//# sourceMappingURL=select-consensus-precomputed.js.map

package/build/tests/consensus/select-consensus-precomputed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"select-consensus-precomputed.js","sourceRoot":"","sources":["../../../tests/consensus/select-consensus-precomputed.ts"],"names":[],"mappings":"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"}

package/build/tests/consensus/types.js

@@ -1,15 +0,0 @@
-export var Permission;
-(function (Permission) {
-    Permission["None"] = "None";
-    Permission["Signature"] = "Signature";
-})(Permission || (Permission = {}));
-export function GetSlot(slot) {
-    for (let i = 0; i < slot.length; i++) {
-        const slotElement = parseInt(slot[i]);
-        if (!isNaN(slotElement)) {
-            return slotElement;
-        }
-    }
-    throw new Error('Invalid slot');
-}
-//# sourceMappingURL=types.js.map

package/build/tests/consensus/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../tests/consensus/types.ts"],"names":[],"mappings":"AA4CA,MAAM,CAAN,IAAY,UAGX;AAHD,WAAY,UAAU;IACpB,2BAAa,CAAA;IACb,qCAAuB,CAAA;AACzB,CAAC,EAHW,UAAU,KAAV,UAAU,QAGrB;AAsGD,MAAM,UAAU,OAAO,CAAC,IAAc;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACtC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC;YACxB,OAAO,WAAW,CAAC;QACrB,CAAC;IACH,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;AAClC,CAAC"}