vesl

Verifiable Execution and Settlement Layer

Build on infrastructure where every computation is provable and every state transition is verified. No trust required.

  addr   00 01 02 03 04 05 06 07   08 09 0a 0b 0c 0d 0e 0f
  0000   76 65 73 6c 2e 70 72 6f   6f 66 2e 76 65 72 69 66
  0010   69 65 64 00 73 74 61 74   65 2e 63 6f 6d 6d 69 74
  0020   00 6e 6f 63 6b 2e 65 78   65 63 00 64 65 74 65 72
  0030   6d 69 6e 69 73 74 69 63   00 76 65 72 69 66 69 61
  0040   62 6c 65 2e 62 79 2e 64   65 66 61 75 6c 74 00 00
  0050   63 6f 6d 6d 69 74 6d 65   6e 74 2e 68 61 73 68 00
  0060   70 72 6f 6f 66 2e 76 61   6c 69 64 00 00 00 00 00

verifiable by default

Every operation produces a cryptographic proof. Not as an add-on. Not as a premium feature. As the foundation. If it ran, you can verify it. If you can't verify it, it didn't run.

+------------------------------------------+
|  nock formula  [8 [1 0] 8 [1 6 [5 [0 7] |
|                [4 0 6]] [0 6] 9 2 [0 2]  |
|                [4 0 6] 0 7]              |
|  subject       [42 0]                    |
|  product       42                        |
|  verified      true                      |
|  cycles        7                         |
+------------------------------------------+
|  ::  decrement gate                      |
|  |=  a=@                                 |
|  =|  i=0                                 |
|  ?:  =(i a)  i                           |
|  $(i +(i))                               |
+------------------------------------------+

nockchain native

Nock is a minimal, deterministic virtual machine. Same input, same output, every time. Your application logic compiles down to something a machine can prove and anyone can verify. No opaque runtimes. No trust assumptions.

  # vesl.toml
  nock_home       = "../../nockchain"
  settlement_mode = "fakenet"
  api_port        = 3000

  # chain settings
  chain_endpoint  = "http://localhost:9090"
  tx_fee          = 256

  $ make build
  $ make demo-fakenet

build in rust, settle on-chain. that's it.

You write Rust — configure your settlement mode, point at a network, and ship. Don't know Hoon? You're not alone. The kernels are already compiled, so you won't need to.

  on-chain
  └─ settle proof         ✓  1 txn

  off-chain (vesl)
  ├─ execute              ✓  nock
  ├─ prove                ✓  zk
  └─ state transition     ✓  verified

  chain sees: proof
  chain does: verify
  chain cost: constant

this is how nockchain scales

Move computation off-chain. Prove it happened correctly. Only the proof settles. The chain never re-executes your logic — it just verifies. Complexity grows off-chain; on-chain cost stays constant.