[Task]: Miden Block Explorer

[0xs34n]

Node's components affected by this task

• [X] RPC
• [ ] Block producer
• [ ] Store
• [ ] Protobuf messages
• [ ] Testing

What should be done?

Hi team, my name is Sean and our team will help build the Miden block explorer. We are the team behind Starkscan.

To help get started, we'll need data from the RPC node.

Based on my limited knowledge of Miden, we could retrieve the following data:

Blocks

• Block
  • Block Hash
  • Block Number/Height
  • Previous Block Hash
  • Block Proof
  • Timestamp
  • Version
  • Transactions
    • Batch proofs?
  • State commitments
    • account DB commitment
    • nullifier DB commitment
    • notes DB commitment
  • State updates/diffs
    • created new notes
    • updated account state hashes
    • script roots of consumed notes
    • new nullifiers
  • public accounts and notes

Accounts

• Account
  • ID
    • hash
    • account type?
      • regular
      • immutable
      • faucet
        • fungible
        • non-fungible
    • ? storage mode?
      • public or private
  • nonce
    • number
  • storage
  • vault
    • array of assets
  • code
    • array of functions

Notes

• Note
  • ID/serial number
  • public or private
    • note hash if private note
  • array of assets
    • hash
    • array of assets
  • script (methods being executed in account smart contract)
    • code
  • inputs (input data that gets passed into script)
    • array of inputs and types
  • note tag (to find the note for accounts)

Transactions

• Transaction
  • inputs
    • account
      • account ID
      • account code
    • blockHeader
    • ChainMmr? / success consumption?
    • array of input (such as InputNote if consuming a note)
      • input
        • array of note ID
  • outputs
    • account ID’
    • transactionWitness
    • array of output (such as OutputNote if emitting a note)
      • output
        • array of note ID

Nullfiiers

• Nullifier
  • Note ID
  • Block IDan

How should it be done?

• Expose testnet data via RPC endpoints.
• Run a stable testnet node such that data can be retrieved externally.
• Data structure changes kept to a minimum. Changes ideally append-only.

When is this task done?

• There is a public testnet node running at an endpoint
• Public testnet data can be retrieved from the node externally
• The node is live and stable

Additional context

Here is a high-level overview of the design of the block explorer

Data from the Miden node will be indexed into a database for analysis, retrieval, filtering, sorting, and searching purposes. The indexed data is exposed to the frontend app via GraphQL and REST APIs.

[bobbinth]

@0xs34n thank you for such a detailed description! A few comments below:

Based on my limited knowledge of Miden, we could retrieve the following data:

A few comments on what's currently available:

• Blocks: we have an endpoint to return block headers information about created notes, updated accounts etc. Some of this information is stored (e.g., notes created in each block) and could be easily exposed via new endpoints. Other info (e.g., account diffs) is not currently stored, though we have plans to store more info in the future.
• Accounts: currently, we store only the latest states of accounts. For off-chain accounts that's just ID + hash of the state; for public accounts that's full account details. We also plan to keep track of state diffs for public accounts over time.
  • One additional info that we track for each account is the block height at which a given account was updated.
• Notes: all information about notes is tracked (or will be tracked in the very near future). There will be an endpoint to retrieve note info by note ID. However, we currently don't have a way to retrieve all notes for a given block.
• Transactions: These are currently not tracked (in fact, all info about transactions is currently erased at the time a new block is created). We are still exploring different approaches to what exactly should be stored and how.
• Nullifiers: all nullifiers are stored but we don't currently have an endpoint to retrieve them.

As can be seen from above, we are missing quite a few endpoints that would be useful to you. I think there are a couple of approaches to remedy this:

1. We could create individual endpoints to retrieve some of the missing data (e.g., GetNotesForBlock).
2. We could create an endpoint to retrieve full block data (this could be something like GetBlockById or maybe a streaming service returning something similar to ApplyBlockRequest messages).

Each of these has pros and cons - though, I think in the longer term, the second approach is probably the right one.

Do you guys have any preferences?

[0xs34n]

Either of the endpoints are fine, don't think we'll need a streaming service at this time. Thanks!

[bobbinth]

GetBlockByNumber endpoint was implemented in #340 and we'll include it into the next release (which is planned to be done in the next week or so).

[0xs34n]

Congrats on the alpha launch!

Let us know when the GetBlockByNumber endpoint is available so we can start indexing.

[bobbinth]

Congrats on the alpha launch!

Let us know when the GetBlockByNumber endpoint is available so we can start indexing.

Thank you! We've deployed the v0.3.0 node (with GetBlockByNumber) to our testnet (18.203.155.106) recently. Take a look and let us know if you run into any issues/questions.

[Dominik1999]

Requested

https://github.com/0xPolygonMiden/miden-node/issues/374 https://github.com/0xPolygonMiden/miden-node/issues/375

[bobbinth]

Closing this as most (all?) functionality should not be available in the block struct return from the GetBlockByNumber endpoint. @0xs34n - if anything is still outstanding, could you create issue(s) for that?