From 429f8684d98891a65bae7f5ab947a1b777fd072e Mon Sep 17 00:00:00 2001 From: Ivan Gavran Date: Thu, 30 Mar 2023 09:43:09 +0200 Subject: [PATCH 01/14] Added Quint specification --- formal_spec/ITF_files/panicIssue.itf.json | 2297 +++++++++++++++++++++ formal_spec/ITF_files/runTest.itf.json | 1 + formal_spec/nmt.qnt | 847 ++++++++ go.mod | 3 + go.sum | 7 + simulation_test.go | 169 ++ 6 files changed, 3324 insertions(+) create mode 100644 formal_spec/ITF_files/panicIssue.itf.json create mode 100644 formal_spec/ITF_files/runTest.itf.json create mode 100644 formal_spec/nmt.qnt create mode 100644 simulation_test.go diff --git a/formal_spec/ITF_files/panicIssue.itf.json b/formal_spec/ITF_files/panicIssue.itf.json new file mode 100644 index 0000000..2eea352 --- /dev/null +++ b/formal_spec/ITF_files/panicIssue.itf.json @@ -0,0 +1,2297 @@ +{"states": +[ + { + "proof_v": { + "start": 0, + "end": 0, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": true, + "corruption_type": "end", + "corruption_diff": { + "changed_start": -1, + "changed_end": 0, + "changed_namespace": -1, + "changed_indices": [] + } + }, + + { + "proof_v": { + "start": 0, + "end": 0, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": true, + "corruption_type": "end", + "corruption_diff": { + "changed_start": -1, + "changed_end": 0, + "changed_namespace": -1, + "changed_indices": [] + } + }, +{ + "proof_v": { + "start": 0, + "end": 0, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": true, + "corruption_type": "end", + "corruption_diff": { + "changed_start": -1, + "changed_end": 0, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 0, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": true, + "corruption_type": "end", + "corruption_diff": { + "changed_start": -1, + "changed_end": 0, + "changed_namespace": -1, + "changed_indices": [] + } + }, +] +} \ No newline at end of file diff --git a/formal_spec/ITF_files/runTest.itf.json b/formal_spec/ITF_files/runTest.itf.json new file mode 100644 index 0000000..83d641b --- /dev/null +++ b/formal_spec/ITF_files/runTest.itf.json @@ -0,0 +1 @@ +{"#meta":{"source":"nmt.qnt","status":"ok","generatedBy":"Quint","timestamp":1680161414524},"vars":["proof_v","tree_v","namespace_v","state_v","leaves_v","corrupted","corruption_type","corruption_diff"],"states":[{"proof_v":{"start":-1,"end":-1,"supporting_hashes":[]},"tree_v":{"leaves":{"#map":[]},"hashes":{"#map":[]}},"namespace_v":-1,"state_v":"init","leaves_v":[],"corrupted":false,"corruption_type":"","corruption_diff":{"changed_start":-1,"changed_end":-1,"changed_namespace":-1,"changed_indices":[]}}]} \ No newline at end of file diff --git a/formal_spec/nmt.qnt b/formal_spec/nmt.qnt new file mode 100644 index 0000000..d147874 --- /dev/null +++ b/formal_spec/nmt.qnt @@ -0,0 +1,847 @@ +// -*- mode: Bluespec; -*- + +// This file contains a Quint specification of the (part of the) Namespaced Merkle Tree +// library. +// The specification is written in Quint (https://github.com/informalsystems/quint), a modern specification +// language based on TLA. +// +// The file is split into five modules: +// - basics: some basic functions and types +// - nmt_helpers: helper function (e.g., generation of trees, pairwise hashing etc.) +// - nmt: creation of NMT proof and their verification +// - nmtProofVerification: actions that generate proofs and verify them, thereby checking if +// the logic of the spec is sound +// - nmtTest: actions that generate proof and non-deterministically corrupt them afterwards, +// whose output can be used in test generation +// +// The specification models Inclusion proofs, but does not model Absence proofs. + +module basics{ + + type BINARY = List[int] + + def binary(n: int) : BINARY = + if (n == 0) + [0] + else + range(0,n).foldl( + [], + (acc, i) => { + val c = n / 2^i + if (c > 0) + [c % 2].concat(acc) + else + acc + } + ) + + // this function gets the first power of + // 2 which is greater than `lastNode` + def getFullTreeSize(lastNode : int) : int = + if (lastNode == 0) + 1 + else + 2^length(binary(lastNode)) + + def sum(list: List[int]) : int = + list.foldl(0, (acc, i) => acc + i) + + def min(S: Set[int]) : int = + // val tentativeMin = chooseSome(S) ---> chooseSome is not supported yet + val tentativeMin = -1 + S.fold( + tentativeMin, + (acc, i) => if ((acc == tentativeMin) or (i < acc)) i else acc + ) + + def listToSet(S: List[int]) : Set[int] = + S.foldl(Set(), (acc, i) => acc.union(Set(i))) + + + def setToSortedList(S: Set[int]) : List[int] = + S.fold( + [], + (acc, i) => acc.concat( + [min(S.exclude(listToSet(acc)))] + ) + ) + + def max(S: Set[int]) : int = + // val tentativeMax = chooseSome(S) --> chooseSome not supported yet + val tentativeMax = -1 + S.fold( + tentativeMax, + (acc, i) => if ((acc == -1) or (i > acc)) i else acc + ) + + + + + def reverse(L: List[x]) : List[x] = + L.foldl([], (acc, i) => [i].concat(acc)) + + def getWithDefault(mapX: int -> a, key: int, default: a) : a = + if (mapX.keys().contains(key)) + mapX.get(key) + else + default + + +} + +module nmt_helpers{ + import basics.* + + type NODE_IDX = int + + // hashes will be of type WORD + type WORD = List[(str, int)] + + // each tree is a mapping from node indices (=integers) to the + // corresponding data at leaf nodes and hashes of all nodes. + // the root of the tree has index 1, its child 2 and 3 etc. (as captured in functions + // `getParentIdx`, `getLeftChildidx` and `getRightChildIdx`) + // + type TREE = { + leaves: NODE_IDX -> DATA_ITEM, + hashes: NODE_IDX -> NAMESPACE_HASH + } + + type NAMESPACE_HASH = {minNS: int, maxNS: int, hash: WORD} + + type PROOF = {start: int, end: int, supporting_hashes: List[NAMESPACE_HASH]} + + type DATA = (str, int) + + type DATA_ITEM = {value: DATA, namespaceId: int} + + + def getParentIdx(idx : NODE_IDX) : NODE_IDX = + idx / 2 + + def getLeftChildIdx(idx : NODE_IDX) : NODE_IDX = + 2 * idx + + def getLeftUncleIdx(idx : NODE_IDX, uncle_level : int) : NODE_IDX = + idx/2^uncle_level - 1 + + def getRightUncleIdx(idx : NODE_IDX, uncle_level : int) : NODE_IDX = + idx/2^uncle_level + 1 + + + def getRightChildIdx(idx : NODE_IDX) : NODE_IDX = + 2 * idx + 1 + + // hash is defined trivially, as the identity function. + // When used for testing, it should be replaced by a real hash function + def Hash(data: WORD) : WORD = + data + + def mergeWithLeftAndRight(left: WORD, middle: WORD, right: WORD) : WORD = + concat(concat(left, middle), right) + + + // takes a list and maps it to a new list which contains hashes + // of consecutive pairs of elements from the original list + def pairwiseHash(dataList: WORD) : WORD = + + if (length(dataList) == 1) + dataList + else + range(0, length(dataList)).foldl( + [], + (acc, i) => { + if (i % 2 == 0) + acc + else + acc.concat(Hash(concat([dataList[i-1]],[dataList[i]]))) + } + ) + + def GenerateLeavesCorrectly(power: int, namespaceBordersSet : Set[int]) : List[DATA_ITEM] = + + // add left-most and right-most borders to namespaces + val namespaceBorders = concat( + concat([0], setToSortedList(namespaceBordersSet)), + [2^(power-1)] + ) + + val generated_leaves_dummy_hash : List[DATA_ITEM] = + // for each namespace + range(0, length(namespaceBorders)-1).foldl( + [], + (acc, i) => + acc.concat( + // and for each leaf between two namespaces + range(namespaceBorders[i], namespaceBorders[i+1]).foldl( + [], + // create a data point + (acc2, j) => acc2.concat([{value: ("data", 0), namespaceId: i*2}]) + ) + ) + ) + + // this is mostly for debugging purposes: have data value correspond exactly to the index + // of the leaf. (This enables easier reasoning about the generated proofs later) + val generated_leaves : List[DATA_ITEM] = + range(0, length(generated_leaves_dummy_hash)).foldl( + [], + (acc, i) => acc.concat( + [{value: ("data", i), namespaceId: generated_leaves_dummy_hash[i].namespaceId}] + ) + ) + + generated_leaves + + + + + def BuildTree(leaves: List[DATA_ITEM]) : TREE = + // because of the way trees are represented (nodes enumerated from 1 to 2^n - 1), + // and the assumption of full and complete trees, we know that leaves + // are occupying the half of the tree. Thus, their starting index equals their length + val leaf_idx_start = length(leaves) + + val tree_leaves : NODE_IDX -> DATA_ITEM = + range(0, length(leaves)).foldl( + Map(), + (acc, i) => acc.put(leaf_idx_start + i, leaves[i]) + ) + + val tree_leaves_hashes : NODE_IDX -> NAMESPACE_HASH = + range(0, length(leaves)).foldl( + Map(), + (acc, i) => + acc.put( + leaf_idx_start + i, + {minNS: leaves[i].namespaceId, maxNS: leaves[i].namespaceId, hash: Hash([leaves[i].value])}) + ) + + // starting from leaves, calculating the hashes for all other nodes + // of the tree + val tree_hashes : NODE_IDX -> NAMESPACE_HASH = + reverse(range(1, leaf_idx_start)).foldl( + tree_leaves_hashes, + (acc, i) => + acc.put( + i, + { + // minimum is the minimum of the left child because of the ordering assumption + minNS: acc.get(getLeftChildIdx(i)).minNS, + // max is the max of the right child because of the ordering assumption + maxNS: acc.get(getRightChildIdx(i)).maxNS, + hash: Hash( + concat( + acc.get(getLeftChildIdx(i)).hash, + acc.get(getRightChildIdx(i)).hash + ) + ) + } + ) + ) + + {leaves: tree_leaves, hashes: tree_hashes} + + + + + +} + + + +module nmt { + // ASSUMPTIONS/LIMITATIONS: + // - each tree is full and complete (2^n leaves at the bottom level) + // - not modelling ignoring max namespace + + import basics.* + import nmt_helpers.* + + + + + + + pure val MAX_POWER = 3 + pure val MAX_NAMESPACE_ID = 100 + pure val EMPTY_PROOF = {start: -1, end: -1, supporting_hashes: []} + pure val EMPTY_TREE = {leaves: Map(), hashes: Map()} + pure val EMPTY_LEAVES = [] + + + + + + + def CreateProofNamespace(namespaceId: int, tree: TREE): PROOF = + val leavesStart = min(tree.leaves.keys()) + // take only those keys that are of the desired namespace + val relevantLeavesKeys = tree.leaves.keys().fold( + Set(), + (acc, i) => + if (tree.leaves.get(i).namespaceId == namespaceId) + union(acc, Set(i)) + else + acc + ) + val start = min(relevantLeavesKeys) + + // we want to get the binary representation of the number leaves from the `start` (first node of the + // leaves that go to the proof) and the very beginning of leaves because this encodes left siblings, + // uncles, etc., which are needed for the merkle proof. The fact that we use it reversed is because the + // proof defines the nodes to be in-order, thus, older ancestors come first (bcs they are more left) + val binaryLeftLimitDistanceReversed = reverse(binary(start - leavesStart)) + + val left_hashes : List[NAMESPACE_HASH] = + range(0, length(binaryLeftLimitDistanceReversed)).foldl( + [], + (acc, i) => + if (binaryLeftLimitDistanceReversed[i] == 1) + concat([tree.hashes.get(getLeftUncleIdx(start, i))], acc) + else + acc + ) + + val end = max(relevantLeavesKeys) + val binaryRightLimitDistanceReversed = reverse(binary(2*leavesStart-1 - end)) + + val right_hashes : List[NAMESPACE_HASH] = + range(0, length(binaryRightLimitDistanceReversed)).foldl( + [], + (acc, i) => + if (binaryRightLimitDistanceReversed[i] == 1) + acc.concat([tree.hashes.get(getRightUncleIdx(end, i))]) + else + acc + ) + + // start needs to be expressed relative to leaves start and so does end. + { + start: start - leavesStart, + // the +1 is because the range has to be non-inclusive at the right side + end: end - leavesStart +1, + supporting_hashes: concat(left_hashes, right_hashes) + } + + + def SensibleStartEnd(start: int, end: int) : bool = + and { + start >= 0, + start < end + } + + + + // all leaf nodes in the proof should have the same namespace + def CorrectNamespaceValue(proof: PROOF, namespaceId: int, leaves: List[DATA_ITEM]) : bool = + val elementsWithWrongId = leaves.select(x => x.namespaceId != namespaceId) + length(elementsWithWrongId) == 0 + + + + def MerkleRangeHash(proof: PROOF, leaves: List[DATA_ITEM]) : WORD = + + // the number of leaves in a complete subtree that covers the last leaf + // in the proof + val fullTreeSize = getFullTreeSize(proof.end - 1) + + // binary representation of the nodes to the left of proof.start. + // Binary representation captures well left uncles needed for the Merkle proof. + val binaryLeftLimitDistance = binary(proof.start) + + val binaryRightLimitDistance = binary(fullTreeSize - proof.end) + + // create a mapping levelOfTheTree -> hash. This enables knowing which of the supporting_hashes + // is used on which level of the tree (from the left side) + val leftMap : int -> WORD = + range(0, length(binaryLeftLimitDistance)).foldl( + Map(), + (accMap, i) => + // if the bit is 1, then the left uncle from the tree level i is necessary in the Merkle proof + if (binaryLeftLimitDistance[i] == 1) + accMap.put( + // reversing: because the supporting nodes are given in-order, closer relatives of + // the leaf node will come the last + length(binaryLeftLimitDistance) - 1 - i, + // adding the first unused of the supporting hashes (hence, key equals to the size of the growing map) + proof.supporting_hashes[size(accMap.keys())].hash + ) + else + accMap + ) + + // similarly to leftMap, the rightMap holds the mapping of the supporting leaves from the right side of the + // range + val rightMap : int -> WORD = + range(0, length(binaryRightLimitDistance)).foldl( + Map(), + (accMap, i) + => + if (binaryRightLimitDistance[i] == 1) + accMap.put( + i, + proof.supporting_hashes[sum(binaryLeftLimitDistance) + size(accMap.keys())].hash + ) + else + accMap + ) + + val numLeavesUsed = sum(binaryLeftLimitDistance)+sum(binaryRightLimitDistance) + + + // after the left and right maps are created, the remaining supporting hashes + // are the ones that are not used. They are necessarily on the right side of the leaf range + // and can be treated as a proof path in a regular (not the range-based) Merkle tree + val remainingSupportNodes : List[NAMESPACE_HASH] = + if (numLeavesUsed == length(proof.supporting_hashes)) + [] + else + proof.supporting_hashes.slice(numLeavesUsed,length(proof.supporting_hashes)) + + // height of the smallest tree which starts at the leaf index 0 and encompasses the whole range + val treeHeight : int = + if (proof.end == 1) 1 else length(binary(proof.end-1)) + 1 + + + // a list of hashes of the leaves in the [start, end) range + val leafHashes: WORD = + leaves.foldl( + [], + (acc, leaf) => acc.concat(Hash([leaf.value])) + ) + + val partialTreeRootHash : WORD = + // Fold over the levels of the tree, starting from the leaf level. + // Progress to the next level by hashing pairs of hashes from the previous level. + // Each level is half the size of the previous one until finally a list containing a single hash is returned. + range(0,treeHeight).foldl( + leafHashes, + // pairwiseHash will map a list to a new list by taking a hash of every two consecutive values + (acc, i) => pairwiseHash( + mergeWithLeftAndRight( + getWithDefault(leftMap, i, []), + acc, + getWithDefault(rightMap, i, []) + ) + ) + ) + + // having computed the partialTreeRootHash, we can now treat the rest of the supporting hashes + // as a regular Merkle inclusion proof and starting from the `partialTreeRootHash` chain the hashes + // computation. + val calculatedRootHash : WORD = remainingSupportNodes.foldl( + partialTreeRootHash, + (acc, levelHashes) => Hash(acc.concat(levelHashes.hash)) + ) + + calculatedRootHash + + + // none of the proof nodes should have an overlap with the `namespaceId` + def Completeness(proof: PROOF, namespaceId: int) : bool = + val allSupportingNamespaceIds = + proof.supporting_hashes.foldl( + Set(), + (acc, el) => union(acc, el.minNS.to(el.maxNS)) + ) + + not(allSupportingNamespaceIds.contains(namespaceId)) + + + def verifyInclusionProof(proof: PROOF, rootHash: NAMESPACE_HASH, namespaceId: int, leaves: List[DATA_ITEM]) : bool = { + + and { + SensibleStartEnd(proof.start, proof.end), + CorrectNamespaceValue(proof, namespaceId, leaves), + Completeness(proof, namespaceId), + rootHash.hash == MerkleRangeHash(proof, leaves) + } + } + +} + + +module nmtProofVerification { + + // this module iteratively generates a proof and then verifies it. + // run by: + // quint run --main=nmtProofVerification --max-samples=1 --max-steps=100 nmt.qnt --invariant=verificationAlwaysCorrect + // to run the simulation for 100 steps and check the invariant `verificationAlwaysCorrect` + + + import basics.* + import nmt_helpers.* + import nmt.* + + var proof_v : PROOF + var tree_v : TREE + var namespace_v : int + var verification_success_v : bool + var state_v : string + + + action init = { + all{ + tree_v' = EMPTY_TREE, + proof_v' = EMPTY_PROOF, + verification_success_v' = false, + state_v' = "requirements", + namespace_v' = -1 + } + } + + // step is modelled as a loop of the four always repeating states: + // 1) requirements, 2) generation, 3) verification, and 4) final state. + // + // 1) when in the "requirements" or "init" state, a random size of the tree and the namespaces + // corresponding to leaves, + // are generated and one of the namespaces is chosen to generate a proof for + // 2) when in the "generation" state, a proof is generated for the generated tree and the chosen namespace + // 3) when in the "verification" state, that proof is verified + // 4) final step collects all the results + // + // The three steps happen one after another (no non-determinism involved) + action step = { + any{ + + // 1): requirements + all{ + // state precondition + state_v == "requirements", + // update state for the next step + state_v' = "generation", + + nondet power = oneOf(3.to(MAX_POWER)) + //TODO: there must be a better way to generate this set + nondet namespaceBordersSet = 1.to(2^(power-1) - 2).powerset().filter(x => size(x) > 1).oneOf() + val leaves = GenerateLeavesCorrectly(power, namespaceBordersSet) + all{ + val tree = BuildTree(leaves) + all{ + tree_v' = tree, + nondet namespaceId = tree.leaves.keys().fold( + Set(), + (acc, leaf_key) => + union(acc, Set(tree.leaves.get(leaf_key).namespaceId)) + ).oneOf() + namespace_v' = namespaceId, + } + }, + proof_v' = proof_v, + verification_success_v' = verification_success_v, + }, + + // 2): generation + all{ + // state preconditions + state_v == "generation", + // update state for the next step + state_v' = "verification", + proof_v' = CreateProofNamespace(namespace_v, tree_v), + namespace_v' = namespace_v, + verification_success_v' = verification_success_v, + tree_v' = tree_v + }, + + // 3): verification + all{ + // state preconditions + state_v == "verification", + // update state for the next step + state_v' = "final", + namespace_v' = namespace_v, + + val min_leaf_key = min(tree_v.leaves.keys()) + val max_leaf_key = max(tree_v.leaves.keys()) + val leaves : List[DATA_ITEM] = + range(min_leaf_key, max_leaf_key+1) + .foldl( + [], + (acc, leaf_key) => + if ((proof_v.start <= leaf_key - min_leaf_key) and (leaf_key - min_leaf_key < proof_v.end)) + acc.append( + tree_v.leaves.get(leaf_key) + ) + else + acc + ) + + verification_success_v' = verifyInclusionProof(proof_v, tree_v.hashes.get(1), namespace_v, leaves), + tree_v' = tree_v, + proof_v' = proof_v, + }, + + // 4): collecting all results + all { + // state preconditions + state_v == "final", + //update state for the next step + state_v' = "requirements", + // resetting the state to initial values + namespace_v' = -1, + tree_v' = EMPTY_TREE, + proof_v' = EMPTY_PROOF, + verification_success_v' = false, + } + } + } + + // this invariant states that after the full loop of states, + // verification will be successful + val verificationAlwaysCorrect = + (state_v == "final") implies (verification_success_v == true) +} + + +module nmtTest { + + // this module iteratively generates a proof and then non-deterministically corrupts it. + // run by: + // quint run --main=nmtTest --max-samples=1 --max-steps=100 nmt.qnt --out-itf=ITF_files/out.itf.json + // to simulate 100 steps and save output into `out.itf.json`. This output can be used to generate + // test cases (eg., in `simulation_test.go`) + + import basics.* + import nmt_helpers.* + import nmt.* + + var proof_v : PROOF + var tree_v : TREE + var namespace_v : int + var state_v : string + var leaves_v : List[DATA_ITEM] + var corrupted : bool + var corruption_type : string + var corruption_diff : {changed_start: int, changed_end: int, changed_namespace: int, changed_indices: List[int]} + + action init = { + all{ + tree_v' = EMPTY_TREE, + proof_v' = EMPTY_PROOF, + corrupted' = false, + state_v' = "init", + namespace_v' = -1, + leaves_v' = EMPTY_LEAVES, + corruption_type' = "", + corruption_diff' = + { + changed_start: -1, + changed_end: -1, + changed_namespace: -1, + changed_indices: [] + } + + } + } + + action requirements = { + all{ + // state precondition + state_v == "requirements", + // update state for the next step + state_v' = "generation", + + nondet power = oneOf(3.to(MAX_POWER)) + //TODO: there must be a better way to generate this set + nondet namespaceBordersSet = 1.to(2^(power-1) - 2).powerset().filter(x => size(x) > 1).oneOf() + val leaves = GenerateLeavesCorrectly(power, namespaceBordersSet) + all{ + val tree = BuildTree(leaves) + all{ + leaves_v' = leaves, + tree_v' = tree, + nondet namespaceId = tree.leaves.keys().fold( + Set(), + (acc, leaf_key) => + union(acc, Set(tree.leaves.get(leaf_key).namespaceId)) + ).oneOf() + namespace_v' = namespaceId, + } + }, + // unchanged variables + proof_v' = proof_v, + corrupted' = corrupted, + corruption_type' = corruption_type, + corruption_diff' = corruption_diff + } + } + + action generation = { + all{ + // state preconditions + state_v == "generation", + // update state for the next step + state_v' = "final", + proof_v' = CreateProofNamespace(namespace_v, tree_v), + // unchanged variables + namespace_v' = namespace_v, + corrupted' = false, + tree_v' = tree_v, + leaves_v' = leaves_v, + corruption_type' = corruption_type, + corruption_diff' = corruption_diff + } + } + + + + + + + action final = { + all { + // state preconditions + state_v == "final", + //update state for the next step + state_v' = "requirements", + // resetting the state to initial values + namespace_v' = -1, + tree_v' = EMPTY_TREE, + proof_v' = EMPTY_PROOF, + corrupted' = false, + leaves_v' = EMPTY_LEAVES, + corruption_type' = "", + corruption_diff' = + { + changed_start: -1, + changed_end: -1, + changed_namespace: -1, + changed_indices: [] + } + } + } + + action corruptProof = { + all{ + // state preconditions + state_v == "final", + corrupted == false, + + // corrupting the proof + any{ + // corrupting the start value + all{ + proof_v.end != 1, + namespace_v' = namespace_v, + nondet new_start = oneOf( + 0.to(proof_v.end - 1).exclude(Set(proof_v.start)) + ) + all{ + + proof_v' = {start: new_start, end: proof_v.end, supporting_hashes: proof_v.supporting_hashes}, + corruption_type' = "start", + corruption_diff' = corruption_diff.with("changed_start", new_start), + } + }, + + // corrupting the end value + all{ + proof_v.start < proof_v.end - 1, + namespace_v' = namespace_v, + nondet new_end = oneOf(proof_v.start.to(proof_v.end - 1)) + all{ + proof_v' = {start: proof_v.start, end: new_end, supporting_hashes: proof_v.supporting_hashes}, + corruption_type' = "end", + corruption_diff' = corruption_diff.with("changed_end", new_end), + } + + }, + + // corrupting the supporting hashes in a controlled way + all{ + proof_v.supporting_hashes.length() > 1, + namespace_v' = namespace_v, + nondet new_supporting_hashes_indices = oneOf( + 0.to(proof_v.supporting_hashes.length()-1) + .powerset() + .filter( + x => + and{ + size(x) < proof_v.supporting_hashes.length(), + size(x) > 0 + } + ) + ) + val new_supporting_hashes = range(0, proof_v.supporting_hashes.length()) + .foldl( + [], + (acc, i) => + if (new_supporting_hashes_indices.contains(i)) + acc.append(proof_v.supporting_hashes[i]) + else + acc + ) + all{ + proof_v' = {start: proof_v.start, end: proof_v.end, supporting_hashes: new_supporting_hashes}, + corruption_type' = "supporting_hashes", + val new_indices = range(0, proof_v.supporting_hashes.length()) + .foldl( + [], + (acc, i) => + if (new_supporting_hashes_indices.contains(i)) + acc.append(i) + else + acc + ) + corruption_diff' = corruption_diff.with("changed_indices", new_indices), + } + + }, + + // corrupting the namespace value + all{ + proof_v' = proof_v, + nondet newNamespace = 1.to(MAX_NAMESPACE_ID).exclude(Set(namespace_v)).oneOf() + all{ + namespace_v' = newNamespace, + corruption_type' = "namespace", + corruption_diff' = corruption_diff.with("changed_namespace", newNamespace), + } + } + }, + corrupted' = true, + + // unchanged variables + state_v' = state_v, + tree_v' = tree_v, + leaves_v' = leaves_v + } + + + } + + // step is modelled as by 4 states: + // 1) requirements, 2) generation, 2a) corruptProof, and 3) final state. + // + // The state `corruptProof` is marked by 2a because it may be skipped (leaving the proof uncorrupted) + // 1) when in the "requirements" or "init" state, a random size of the tree and the namespaces + // corresponding to leaves, + // are generated and one of the namespaces is chosen to generate a proof for + // 2) when in the "generation" state, a proof is generated for the generated tree and the chosen namespace + // 2a) when in the `final` state, the proof may be corrupted by changing its start, end, nodes, or namespace + // and not transitioning to the next state, but remaining in `final`. (There will be no two corruptions because + // the variable `corrupted` is set to true after the first corruption.) + // 3) when in the `final` state, the state is reset to the initial values + // + // The three steps happen one after another (no non-determinism involved) + action step = { + any{ + + // 1): requirements: defining the tree and the namespace to generate a proof for + requirements, + + // 2): generation of the proof + generation, + + // 2b): corrupting the proof + corruptProof, + + // 3): collecting all results + final + + } + + } + +} diff --git a/go.mod b/go.mod index 8f527cd..54d7bab 100644 --- a/go.mod +++ b/go.mod @@ -10,5 +10,8 @@ require ( require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/tidwall/gjson v1.14.4 // indirect + github.com/tidwall/match v1.1.1 // indirect + github.com/tidwall/pretty v1.2.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index f62dd11..f8a5bba 100644 --- a/go.sum +++ b/go.sum @@ -12,6 +12,13 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/tidwall/gjson v1.14.4 h1:uo0p8EbA09J7RQaflQ1aBRffTR7xedD2bcIVSYxLnkM= +github.com/tidwall/gjson v1.14.4/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= +github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= +github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= +github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/simulation_test.go b/simulation_test.go new file mode 100644 index 0000000..254ba62 --- /dev/null +++ b/simulation_test.go @@ -0,0 +1,169 @@ +package nmt_test + +import ( + "crypto/sha256" + "io/ioutil" + "testing" + + "github.com/celestiaorg/nmt" + "github.com/celestiaorg/nmt/namespace" + "github.com/tidwall/gjson" +) + +const nidSize = 2 + +func getLeavesFromState(state gjson.Result, nidSize int) [][]byte { + itf_leaves := state.Get("leaves_v").Array() + var leaves [][]byte + + for _, itf_leaf := range itf_leaves { + stateNamespace := int(itf_leaf.Get("namespaceId").Int()) + dataString := itf_leaf.Get("value.#tup.1").String() + pushData := namespace.PrefixedData(append( + intToBytes(stateNamespace, nidSize), + []byte(dataString)...)) + leaves = append(leaves, pushData) + + } + return leaves +} + +// checking if the proof generated by the execution matches the proof in the model +// hashes are not checked because the model is using a simplified hash function +func checkProof(modelProof gjson.Result, execProof nmt.Proof, nidSize int) bool { + modelProofStart := int(modelProof.Get("start").Int()) + execProofStart := execProof.Start() + + modelProofEnd := int(modelProof.Get("end").Int()) + execProofEnd := execProof.End() + if modelProofStart != execProofStart || modelProofEnd != execProofEnd { + return false + } + supporting_hashes := modelProof.Get("supporting_hashes").Array() + if len(supporting_hashes) != len(execProof.Nodes()) { + return false + } + for idx, supporting_hash := range supporting_hashes { + modelMinNS := int(supporting_hash.Get("minNS").Int()) + execMinNs := bytesToInt(execProof.Nodes()[idx][:nidSize]) + if modelMinNS != execMinNs { + return false + } + + modelMaxNS := int(supporting_hash.Get("maxNS").Int()) + execMaxNs := bytesToInt(execProof.Nodes()[idx][nidSize:(2 * nidSize)]) + if modelMaxNS != execMaxNs { + return false + } + } + + return true + +} + +func intToBytes(n int, bytesSize int) []byte { + b := make([]byte, bytesSize) + for i := 0; i < bytesSize; i++ { + b[i] = byte(n >> (8 * (bytesSize - i - 1))) + } + return b +} + +func bytesToInt(bytes []byte) int { + var result int + for i, b := range bytes { + shift := uint((len(bytes) - 1 - i) * 8) + result |= int(b) << shift + } + return result +} + +func TestFromITF(t *testing.T) { + + var tree *nmt.NamespacedMerkleTree + + itfFileName := "formal_spec/ITF_files/runTest.itf.json" + // itfFileName := "formal_spec/ITF_files/panicIssue.itf.json" + data, err := ioutil.ReadFile(itfFileName) + if err != nil { + t.Errorf("Error opening file: %v", err) + } + states := gjson.GetBytes(data, "states").Array() + + // iterate over all states of the test run + for stateIdx, state := range states { + t.Logf("State %v\n", stateIdx) + // because the test run consists of multiple steps to generate the tree and the proof, test + // only the states marked "final" + if state.Get("state_v").String() == "final" { + modelNamespace := int(state.Get("namespace_v").Int()) + modelLeaves := getLeavesFromState(state, nidSize) + modelProof := state.Get("proof_v") + corrupted := state.Get("corrupted").Bool() + t.Logf("Obtained state data:\n\tState namespace: %v\n\tleaves: %v\n\tcorrupted: %v\n", + modelNamespace, modelLeaves, corrupted) + + tree = nmt.New(sha256.New(), nmt.NamespaceIDSize(nidSize)) + for _, leaf := range modelLeaves { + err := tree.Push(leaf) + if err != nil { + t.Errorf("Error on push: %v", err) + } + } + + namespaceBytes := intToBytes(modelNamespace, nidSize) + + proof, err := tree.ProveNamespace(namespaceBytes) + if err != nil { + t.Errorf("Error on prove: %v", err) + } + var new_hashes [][]byte + t.Logf("Proof: %v\n", proof) + + var corruption_type string + if !corrupted { + proofMatching := checkProof(modelProof, proof, nidSize) + if !proofMatching { + t.Errorf("Proofs do not match. Expected: %v, got: %v", state, proof) + } + } else { + // CORRUPTED: now we are modifying the proof to be corrupted here as well + corruption_type = state.Get("corruption_type").String() + t.Log("Corruption type: ", corruption_type) + if corruption_type == "supporting_hashes" { + for idx := 0; idx < len(state.Get("corruption_diff.changed_indices").Array()); idx++ { + new_hashes = append(new_hashes, proof.Nodes()[idx]) + } + } else { + new_hashes = proof.Nodes() + } + proof = nmt.NewInclusionProof( + int(modelProof.Get("start").Int()), + int(modelProof.Get("end").Int()), + new_hashes, + true, + ) + t.Logf("Corrupted proof: %v\n", proof) + + } + + root, _ := tree.Root() + + dataToVerify := modelLeaves[proof.Start():proof.End()] + + t.Logf("Verifying. Root: %v, Namespace: %x, Leaves: %v, Proof: %v\n", root, namespaceBytes, dataToVerify, proof) + + successVerification := proof.VerifyNamespace(sha256.New(), namespaceBytes, dataToVerify, root) + t.Logf("Verification result: %v\n", successVerification) + + if successVerification == corrupted { + successVerification := proof.VerifyNamespace(sha256.New(), namespaceBytes, dataToVerify, root) + t.Errorf("Mismatch! Data corrupted = %v, verification result = %v", corrupted, successVerification) + } + + } else { // these are the intermediate states, at which we are not checking anything + continue + } + + } +} From c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Thu, 30 Mar 2023 09:55:48 +0200 Subject: [PATCH 02/14] increased the max size of tree, re-generated the test file --- formal_spec/ITF_files/runTest.itf.json | 2 +- formal_spec/nmt.qnt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/formal_spec/ITF_files/runTest.itf.json b/formal_spec/ITF_files/runTest.itf.json index 83d641b..874dc10 100644 --- a/formal_spec/ITF_files/runTest.itf.json +++ b/formal_spec/ITF_files/runTest.itf.json @@ -1 +1 @@ -{"#meta":{"source":"nmt.qnt","status":"ok","generatedBy":"Quint","timestamp":1680161414524},"vars":["proof_v","tree_v","namespace_v","state_v","leaves_v","corrupted","corruption_type","corruption_diff"],"states":[{"proof_v":{"start":-1,"end":-1,"supporting_hashes":[]},"tree_v":{"leaves":{"#map":[]},"hashes":{"#map":[]}},"namespace_v":-1,"state_v":"init","leaves_v":[],"corrupted":false,"corruption_type":"","corruption_diff":{"changed_start":-1,"changed_end":-1,"changed_namespace":-1,"changed_indices":[]}}]} \ No newline at end of file +{"#meta":{"source":"nmt.qnt","status":"ok","generatedBy":"Quint","timestamp":1680162905479},"vars":["proof_v","tree_v","namespace_v","state_v","leaves_v","corrupted","corruption_type","corruption_diff"],"states":[{"proof_v":{"start":-1,"end":-1,"supporting_hashes":[]},"tree_v":{"leaves":{"#map":[]},"hashes":{"#map":[]}},"namespace_v":-1,"state_v":"init","leaves_v":[],"corrupted":false,"corruption_type":"","corruption_diff":{"changed_start":-1,"changed_end":-1,"changed_namespace":-1,"changed_indices":[]}}]} \ No newline at end of file diff --git a/formal_spec/nmt.qnt b/formal_spec/nmt.qnt index d147874..f563616 100644 --- a/formal_spec/nmt.qnt +++ b/formal_spec/nmt.qnt @@ -263,7 +263,7 @@ module nmt { - pure val MAX_POWER = 3 + pure val MAX_POWER = 5 pure val MAX_NAMESPACE_ID = 100 pure val EMPTY_PROOF = {start: -1, end: -1, supporting_hashes: []} pure val EMPTY_TREE = {leaves: Map(), hashes: Map()} From 32db2681b8144273e080e2703d62fb21bedf2532 Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Fri, 14 Apr 2023 11:23:44 +0200 Subject: [PATCH 03/14] added example of scenario-based tests in Quint --- formal_spec/ITF_files/scenario.json | 98 ++++++++++++++++++++++++ formal_spec/tests.qnt | 114 ++++++++++++++++++++++++++++ simulation_test.go | 58 +++++++++++++- 3 files changed, 267 insertions(+), 3 deletions(-) create mode 100644 formal_spec/ITF_files/scenario.json create mode 100644 formal_spec/tests.qnt diff --git a/formal_spec/ITF_files/scenario.json b/formal_spec/ITF_files/scenario.json new file mode 100644 index 0000000..165266a --- /dev/null +++ b/formal_spec/ITF_files/scenario.json @@ -0,0 +1,98 @@ +{ + "#meta": { + "source": "tests.qnt", + "status": "violation", + "generatedBy": "Quint", + "timestamp": 1681461155649 + }, + "vars": [ + "leaves_namespace_idx_v", + "namespace_v", + "namespaceIdFound_v" + ], + "testCases": [ + { + "name": "5 leaves and not found but within range", + "states": [ + { + "leaves_namespace_idx_v": [ + 39 + ], + "namespace_v": 56, + "namespaceIdFound_v": false + }, + { + "leaves_namespace_idx_v": [ + 39, + 71 + ], + "namespace_v": 56, + "namespaceIdFound_v": false + }, + { + "leaves_namespace_idx_v": [ + 39, + 71, + 92 + ], + "namespace_v": 56, + "namespaceIdFound_v": false + }, + { + "leaves_namespace_idx_v": [ + 39, + 71, + 92, + 92 + ], + "namespace_v": 56, + "namespaceIdFound_v": false + }, + { + "leaves_namespace_idx_v": [ + 39, + 71, + 92, + 92, + 100 + ], + "namespace_v": 56, + "namespaceIdFound_v": false + } + ] + }, + { + "name": "two leaves and found", + "states": [ + { + "leaves_namespace_idx_v": [ + 42 + ], + "namespace_v": 56, + "namespaceIdFound_v": false + }, + { + "leaves_namespace_idx_v": [ + 42, + 56 + ], + "namespace_v": 56, + "namespaceIdFound_v": true + } + ] + }, + { + "name": "not found", + "states": [ + { + "leaves_namespace_idx_v": [ + 39 + ], + "namespace_v": 94, + "namespaceIdFound_v": false + } + ] + } + ] + +} \ No newline at end of file diff --git a/formal_spec/tests.qnt b/formal_spec/tests.qnt new file mode 100644 index 0000000..643ff8e --- /dev/null +++ b/formal_spec/tests.qnt @@ -0,0 +1,114 @@ +module basics { + + def listToSet(l: List[a]) : Set[a] = + l.foldl(Set(), (acc, x) => union(acc, Set(x))) + + def min(S: Set[int]) : int = + // val tentativeMin = chooseSome(S) ---> chooseSome is not supported yet + val tentativeMin = -1 + S.fold( + tentativeMin, + (acc, i) => if ((acc == tentativeMin) or (i < acc)) i else acc + ) + + + def max(S: Set[int]) : int = + // val tentativeMax = chooseSome(S) --> chooseSome not supported yet + val tentativeMax = -1 + S.fold( + tentativeMax, + (acc, i) => if ((acc == -1) or (i > acc)) i else acc + ) + + +} + +// This module creates leaves with namespaces and a namespace id to search for. +// Its purpose is to create data for tests similar to those from +// nmt_test.go::TestNamespacedMerkleTree_ProveNamespace_Ranges_And_Verify +// +// The approach taken here is different from the one in nmt.qnt: here, +// in every step, one leaf is generated. Thus, the final test data is available in the +// last step + +module tests { + + import basics.* + pure val MAX_NAMESPACE_ID = 100 + + var leaves_namespace_idx_v : List[int] + var namespace_v : int + var namespaceIdFound_v : bool + + // syntactic sugar, for better readability + def require(pred: bool) : bool = pred + + action init = { + nondet first_element = oneOf(0.to(MAX_NAMESPACE_ID)) + nondet namespace = oneOf(0.to(MAX_NAMESPACE_ID)) + all { + leaves_namespace_idx_v' = [first_element], + namespace_v' = namespace, + namespaceIdFound_v' = first_element == namespace + } + } + + action step = { + val l = length(leaves_namespace_idx_v) + val lastElement = leaves_namespace_idx_v[l-1] + nondet new_index = oneOf( + lastElement.to(MAX_NAMESPACE_ID) + ) + all{ + require(lastElement < MAX_NAMESPACE_ID), + leaves_namespace_idx_v' = append(leaves_namespace_idx_v, new_index), + namespace_v' = namespace_v, + namespaceIdFound_v' = (namespaceIdFound_v or (new_index == namespace_v)) + } + } + + // + // test scenarios, as originally described in nmt_test.go + // + + // original test comment (from nmt_test.go): "not found", + val namespaceIdNotFound = + val leavesSet = listToSet(leaves_namespace_idx_v) + not(leavesSet.contains(namespace_v)) + + val namespaceIdNotFoundTest = + not(namespaceIdNotFound) + + + + // original test comment (from nmt_test.go): "two leaves and found" + val twoLeavesAndFound = + and{ + length(leaves_namespace_idx_v) == 2, + val leavesSet = listToSet(leaves_namespace_idx_v) + leavesSet.contains(namespace_v) + } + + val twoLeavesAndFoundTest = + not(twoLeavesAndFound) + + + // original test comment (from nmt_test.go): "5 leaves and not found but within range" + val fiveLeavesAndNotFoundButWithinRange = + val leavesSet = listToSet(leaves_namespace_idx_v) + and{ + length(leaves_namespace_idx_v) == 5, + not(leavesSet.contains(namespace_v)), + min(leavesSet) < namespace_v, + max(leavesSet) > namespace_v + } + + val fiveLeavesAndNotFoundButWithinRangeTest = + not(fiveLeavesAndNotFoundButWithinRange) + + + + + + +} \ No newline at end of file diff --git a/simulation_test.go b/simulation_test.go index 254ba62..45bc798 100644 --- a/simulation_test.go +++ b/simulation_test.go @@ -12,8 +12,8 @@ import ( const nidSize = 2 -func getLeavesFromState(state gjson.Result, nidSize int) [][]byte { - itf_leaves := state.Get("leaves_v").Array() +func getLeavesFromState(state gjson.Result, nidSize int, key string) [][]byte { + itf_leaves := state.Get(key).Array() var leaves [][]byte for _, itf_leaf := range itf_leaves { @@ -97,7 +97,7 @@ func TestFromITF(t *testing.T) { // only the states marked "final" if state.Get("state_v").String() == "final" { modelNamespace := int(state.Get("namespace_v").Int()) - modelLeaves := getLeavesFromState(state, nidSize) + modelLeaves := getLeavesFromState(state, nidSize, "leaves_v") modelProof := state.Get("proof_v") corrupted := state.Get("corrupted").Bool() t.Logf("Obtained state data:\n\tState namespace: %v\n\tleaves: %v\n\tcorrupted: %v\n", @@ -167,3 +167,55 @@ func TestFromITF(t *testing.T) { } } + +func TestFromScenario(t *testing.T) { + itfFileName := "formal_spec/ITF_files/scenario.json" + data, err := ioutil.ReadFile(itfFileName) + if err != nil { + t.Errorf("Error opening file: %v", err) + } + tests := gjson.GetBytes(data, "testCases").Array() + + for _, tt := range tests { + states := tt.Get("states").Array() + lastState := states[len(states)-1] + namespaceId := int(lastState.Get("namespace_v").Int()) + + itf_leaves := lastState.Get("leaves_namespace_idx_v").Array() + + tree := nmt.New(sha256.New(), nmt.NamespaceIDSize(nidSize)) + for _, itf_leaf := range itf_leaves { + leaf_id := int(itf_leaf.Int()) + pushData := namespace.PrefixedData(append( + intToBytes(leaf_id, nidSize), + []byte("dummy_data")...)) + err := tree.Push(pushData) + if err != nil { + t.Fatalf("invalid test case: %v, error on Push(): %v", tt.Get("name").String(), err) + } + } + proveNID := intToBytes(namespaceId, nidSize) + gotProof, err := tree.ProveNamespace(proveNID) + if err != nil { + t.Fatalf("ProveNamespace() unexpected error: %v", err) + } + + gotFound := gotProof.IsNonEmptyRange() && len(gotProof.LeafHash()) == 0 + wantFound := lastState.Get("namespaceIdFound_v").Bool() + + if gotFound != wantFound { + t.Errorf("Proof.ProveNamespace() gotFound = %v, wantFound = %v ", gotFound, wantFound) + } + + // Verification round-trip should always pass: + gotGetLeaves := tree.Get(proveNID) + r, err := tree.Root() + if err != nil { + t.Fatalf("Root() unexpected error: %v", err) + } + gotChecksOut := gotProof.VerifyNamespace(sha256.New(), proveNID, gotGetLeaves, r) + if !gotChecksOut { + t.Errorf("Proof.VerifyNamespace() gotChecksOut: %v, want: true", gotChecksOut) + } + } +} From 7c68820629a6da4fb9d8b9b131b77a7a20ece292 Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Fri, 14 Apr 2023 17:01:19 +0200 Subject: [PATCH 04/14] copied intro to using Quint from the PR description to the README file under formal_spec --- formal_spec/README.md | 96 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 formal_spec/README.md diff --git a/formal_spec/README.md b/formal_spec/README.md new file mode 100644 index 0000000..eae1f21 --- /dev/null +++ b/formal_spec/README.md @@ -0,0 +1,96 @@ +The folder `formal_spec` contains a formal specification of the NMT proof/verification logic in [Quint](https://github.com/informalsystems/quint). + + +# What is Quint? + +[Quint](https://github.com/informalsystems/quint) is a specification language, best suited modeling and analyzing distributed systems. +Quint builds upon Temporal Logic of Actions (TLA) and aims to be easy to learn and use, with state-of-the-art static analysis and development tooling. + + +The benefits of having a Quint specification are threefold: + - It is a precise description of the expected behavior, and yet it resides on a higher level of abstraction than the code. Furthermore, it is executable, which makes it easier to spot and eliminate mistakes in the specification. Module [nmt](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L253) captures the logic of namespace proof generation and verification, and the invariant [`verificationAlwaysCorrect`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L592) is an example of a property against which a specification can be checked. + - It allows for test generation. Module [`nmtTest`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#LL597C17-L597C17) iteratively generates proofs and non-deterministically corrupts them. These generated test runs are exported in a json format (e.g., file [ITF_traces/runTest.itf.json](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/formal_spec/ITF_files/runTest.itf.json)). To be executed as a part of the standard suite, an adapter [simulation_test.go](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/simulation_test.go) is necessary. (The adapter iterates through the json-represented execution state and translates them to function calls.) The generation of the tests happens through simulation. In that sense, it is similar to the existing tests [fuzz_test.go](https://github.com/celestiaorg/nmt/blob/master/fuzz_test.go), except that it also adds corruption of the data. + - Having specifications written in Quint makes it possible to change tests/specs quickly: either by taking advantage of updates to Quint (e.g., going from simulation to exhaustive checks by changing a command) or by virtue of making changes on the level higher than code (and thus less details need to be changed). + +Current limitations: + - the specification does not model absence proofs + - there is an assumption that every tree is full and complete + - the specification does not model special handling of parity namespace (`ignoreMaxNamespace` option). Modelling it correctly depends on the decision of what the desired behaviour is (issue #148 ) + + + +# Intro to Using Quint and the NMT Model + +## Installation + - install `quint` tool by running `npm i @informalsystems/quint -g` (more details [here](https://github.com/informalsystems/quint/blob/main/quint/README.md)) + - install the VSCode plugin from [here](https://marketplace.visualstudio.com/items?itemName=informal.quint-vscode). While this is not necessary, it is of great help when writing models. + +## Basic resources + - a sequence of very gentle and fun tutorials [here](https://github.com/informalsystems/quint/blob/main/tutorials/README.md) + - language [cheatsheet](https://github.com/informalsystems/quint/blob/main/doc/quint-cheatsheet.pdf) + - documentation for built-in operators [here](https://github.com/informalsystems/quint/blob/main/doc/builtin.md) + +## REPL +After installing the quint tool, run the REPL by typing `quint` to terminal. +Then you can play with the REPL by trying some basic expressions, e.g. + - `2+3` + - `val x = Set(1,3,4)` + - `x.powerset()` + - `x.map(i => i*2)` + +## Inspecting the NMT model +As a first step, examine the model operators from within REPL. +Example commands to try out after running `quint` within the `formal_spec` folder: + +``` +.load nmt.qnt + +import basics.* + +import nmt_helpers.* + +import nmt.* + +val c_leaves = [{ value: ("data", 0), namespaceId: 0 }, { value: ("data", 1), namespaceId: 2 }, { value: ("data", 2), namespaceId: 2 }, { value: ("data", 3), namespaceId: 4 }] + +val c_tree = BuildTree(c_leaves) + +val proofZero = CreateProofNamespace(0, c_tree) + +CreateProofNamespace(2, c_tree) + +val c_root = c_tree.hashes.get(1) + +verifyInclusionProof(proofZero, c_root, 0, [{ value: ("data", 0), namespaceId: 0 }]) + +MerkleRangeHash(proofZero, [{ value: ("data", 0), namespaceId: 0 }]) + +verifyInclusionProof(proofZero, c_root, 0, [{ value: ("data", 0), namespaceId: 2 }]) + +import nmtProofVerification.* + +// runs the initialization action +init + +// runs one step of the model +step + +// runs another step of the model +step +``` + +After getting acquainted with all the operators, you can simulate the model behavior by running + + +- `quint run --main=nmtProofVerification --max-samples=1 --max-steps=100 nmt.qnt --invariant=verificationAlwaysCorrect` +This command will run the module `nmtProofVerification`, which iteratively generates data, creates a proof for a namespace and then verifies it. It will run 100 steps of the model and will check that the property `verificationAlwaysCorrect` always holds. It will output the steps to the terminal. (For options, run `quint run --help`) + +- `quint run --main=nmtTest --max-samples=1 --max-steps=100 nmt.qnt --out-itf=ITF_files/out.itf.json` +This command will simulate the module `nmtTest`, which non-deterministically corrupts the generated proof and outputs the simulation steps to the file `ITF_files/out.itf.json`, to be used in tests. + +## Running tests +Once a test file is generated, it is read by `simulation_test.go`, a regular go test. (A path to the json file that should be tested needs to be given - at the moment [hardcoded](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/simulation_test.go#L85) in the code.) + + + + From 9939bf253acd291cc1ffc1053bffdceb45cb165f Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Thu, 4 May 2023 16:08:55 +0200 Subject: [PATCH 05/14] added explanatory comments --- formal_spec/nmt.qnt | 42 ++++++++++++++++++++++++++++++++++-------- simulation_test.go | 4 ++++ 2 files changed, 38 insertions(+), 8 deletions(-) diff --git a/formal_spec/nmt.qnt b/formal_spec/nmt.qnt index f563616..9864d2e 100644 --- a/formal_spec/nmt.qnt +++ b/formal_spec/nmt.qnt @@ -158,6 +158,14 @@ module nmt_helpers{ } ) + // This function takes as parameters: + // - `namespaceBordersSet`: a sorted list of integers which defines borders between different namespaces. + // For instance, [3, 5] would indicate that leaves 0,1,2, belong to a same namespace; leaves 3 and 4 to another namespace; + // leaf 5 and all leaves after 5 to a third namespace. + // - `power`: an integer defining the height of the tree. The tree will have 2^(power-1) leaves + // + // The function returns a list of data items. In this model, we don't care about the data itself, so we just use dummy data. + // Our format for dummy ddata is a pair (str, int), where the first element is always "data" and the second element is the index of the leaf. def GenerateLeavesCorrectly(power: int, namespaceBordersSet : Set[int]) : List[DATA_ITEM] = // add left-most and right-most borders to namespaces @@ -273,7 +281,10 @@ module nmt { - + // This function creates a proof for a given `namespaceId` and a given `tree`. + // Following the NMT documentation (https://github.com/celestiaorg/nmt/blob/master/docs/spec/nmt.md#namespace-proof), + // the tproof consists of `start` and `end` indices and the hashes of the nodes (`supporting_hashes`) that are left siblings + // in the regular Merkle proof of `start` and those that are right hashes in the regular proof of `end-1` def CreateProofNamespace(namespaceId: int, tree: TREE): PROOF = val leavesStart = min(tree.leaves.keys()) // take only those keys that are of the desired namespace @@ -325,21 +336,21 @@ module nmt { } + + def SensibleStartEnd(start: int, end: int) : bool = and { start >= 0, start < end } - - // all leaf nodes in the proof should have the same namespace def CorrectNamespaceValue(proof: PROOF, namespaceId: int, leaves: List[DATA_ITEM]) : bool = val elementsWithWrongId = leaves.select(x => x.namespaceId != namespaceId) length(elementsWithWrongId) == 0 - + // Given `proof` and `leaves`, this function calculates the Merkle roo (which is hash) for that range. def MerkleRangeHash(proof: PROOF, leaves: List[DATA_ITEM]) : WORD = // the number of leaves in a complete subtree that covers the last leaf @@ -435,6 +446,7 @@ module nmt { (acc, levelHashes) => Hash(acc.concat(levelHashes.hash)) ) + // a hash value that is returned calculatedRootHash @@ -720,7 +732,9 @@ module nmtTest { // corrupting the proof any{ - // corrupting the start value + // corrupting the start value: we will change its value, while maintaining the property that it must + // be smaller than `proof_v.end` (we get that by requiring `new_start` to be from the set {0, ..., proof_v.end - 1}). + // We will also require that it is indeed different from `proof_v.start`. all{ proof_v.end != 1, namespace_v' = namespace_v, @@ -735,7 +749,8 @@ module nmtTest { } }, - // corrupting the end value + // corrupting the end value: we will change its value, while maintaining the property that it must + // be greater than start by at least 1 (we get that by requiring `new_end` to be from the set {proof_v.start, ..., proof_v.end - 1}) all{ proof_v.start < proof_v.end - 1, namespace_v' = namespace_v, @@ -748,10 +763,14 @@ module nmtTest { }, - // corrupting the supporting hashes in a controlled way + // corrupting the supporting hashes in a controlled way: we will take a subset of existing supporting hashes all{ proof_v.supporting_hashes.length() > 1, namespace_v' = namespace_v, + // We use the original set of indices and then take a subset of it as a corrupted one. + // We do so by selecting `oneOf` from the set of all subsets of existing indices (`powerse`), + // provided that it is not the empty set and not the full set of indices. (`filter`). + // Note that this is non-deterministic value (`nondet`) because of the function `oneOf`. nondet new_supporting_hashes_indices = oneOf( 0.to(proof_v.supporting_hashes.length()-1) .powerset() @@ -763,6 +782,11 @@ module nmtTest { } ) ) + + // Now we use the calculated subset of indices to extract the corresponding subset of supporting hashes. + // We do so by iterating over the set of indices. Iteration over lists in Quint is done by using the concept of + // the left fold (`foldl`). For more info on `foldl`, check + // https://github.com/informalsystems/quint/blob/main/doc/builtin.md#pure-def-foldl-lista-b-b-a--b--b val new_supporting_hashes = range(0, proof_v.supporting_hashes.length()) .foldl( [], @@ -789,7 +813,9 @@ module nmtTest { }, - // corrupting the namespace value + // corrupting the namespace value: we will change the value of the namespace for which the proof is written. + // We do so by selecting `newNamespace` from the set {1,...,MAX_NAMESPACE_ID}, while requiring that it is + // indeed different from `namespace_v`. all{ proof_v' = proof_v, nondet newNamespace = 1.to(MAX_NAMESPACE_ID).exclude(Set(namespace_v)).oneOf() diff --git a/simulation_test.go b/simulation_test.go index 45bc798..bb19830 100644 --- a/simulation_test.go +++ b/simulation_test.go @@ -137,6 +137,10 @@ func TestFromITF(t *testing.T) { } else { new_hashes = proof.Nodes() } + // We could examine for different corruption types and then only user `modelProof` for + // the corrupted parts of the proof and the rest from the `proof`. The way we do it now, + // however, is not a problem since for non-corrupted parts, `modelProof` and `proof` are + // the same. proof = nmt.NewInclusionProof( int(modelProof.Get("start").Int()), int(modelProof.Get("end").Int()), From 80766b7d8dc57e5ebb11aed68ab861546a05734e Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Thu, 4 May 2023 17:10:59 +0200 Subject: [PATCH 06/14] corrected the issue with generating empty test data file --- formal_spec/ITF_files/runTest.itf.json | 57142 ++++++++++++++++++++++- formal_spec/nmt.qnt | 10 +- 2 files changed, 57146 insertions(+), 6 deletions(-) diff --git a/formal_spec/ITF_files/runTest.itf.json b/formal_spec/ITF_files/runTest.itf.json index 874dc10..d918755 100644 --- a/formal_spec/ITF_files/runTest.itf.json +++ b/formal_spec/ITF_files/runTest.itf.json @@ -1 +1,57141 @@ -{"#meta":{"source":"nmt.qnt","status":"ok","generatedBy":"Quint","timestamp":1680162905479},"vars":["proof_v","tree_v","namespace_v","state_v","leaves_v","corrupted","corruption_type","corruption_diff"],"states":[{"proof_v":{"start":-1,"end":-1,"supporting_hashes":[]},"tree_v":{"leaves":{"#map":[]},"hashes":{"#map":[]}},"namespace_v":-1,"state_v":"init","leaves_v":[],"corrupted":false,"corruption_type":"","corruption_diff":{"changed_start":-1,"changed_end":-1,"changed_namespace":-1,"changed_indices":[]}}]} \ No newline at end of file +{ + "#meta": { + "source": "nmt.qnt", + "status": "ok", + "generatedBy": "Quint", + "timestamp": 1683212911402 + }, + "vars": [ + "proof_v", + "tree_v", + "namespace_v", + "state_v", + "leaves_v", + "corrupted", + "corruption_type", + "corruption_diff" + ], + "states": [ + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 5, + "end": 8, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 8 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 8, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 8, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 14, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 8, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 8, + "end": 9, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 14, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 8 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 8, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 8, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 14, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 8, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 2 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 4 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 10 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 10 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 10 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 2 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 4 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 10 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 10 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 10 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 2 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 4 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 10 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 10 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 38, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 10 + } + ], + "corrupted": true, + "corruption_type": "namespace", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": 38, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 8 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 10 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 8, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 4, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 5, + "end": 6, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 8 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 10 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 8, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 4, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 0 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 4, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 5, + "end": 8, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 0 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 4, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 4, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 4, + "supporting_hashes": [ + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ], + "corrupted": true, + "corruption_type": "supporting_hashes", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [ + 2 + ] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 8 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 8 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 2, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 8 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 8 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 2, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 8 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 8 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": true, + "corruption_type": "start", + "corruption_diff": { + "changed_start": 1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 19, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": true, + "corruption_type": "namespace", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": 19, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 8 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 8, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 8, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 14, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 2, + "end": 4, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 8 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 8, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 8, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 14, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 10, + "end": 11, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 10, + "end": 11, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 93, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": true, + "corruption_type": "namespace", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": 93, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 10, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 14, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 3, + "end": 6, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 10, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 14, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 16 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 0 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 0 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 0 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 5, + "end": 6, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 0 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 0 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 0 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 2, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 2, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 37, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": true, + "corruption_type": "namespace", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": 37, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 4, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 4, + "end": 6, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 4, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 4, + "end": 6, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 50, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": true, + "corruption_type": "namespace", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": 50, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 5, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 5, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": true, + "corruption_type": "supporting_hashes", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [ + 0, + 1 + ] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 12, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 13, + "end": 16, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 12, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 7, + "end": 16, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 12, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 12 + } + ], + "corrupted": true, + "corruption_type": "start", + "corruption_diff": { + "changed_start": 7, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 4, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 5, + "end": 6, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 4, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 8 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 3, + "end": 5, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 8 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 3, + "end": 5, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 8 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 77, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": true, + "corruption_type": "namespace", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": 77, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 5, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 2, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 6 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 4, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 1, + "end": 4, + "supporting_hashes": [ + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 2, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": true, + "corruption_type": "supporting_hashes", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [ + 1 + ] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 31, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": true, + "corruption_type": "namespace", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": 31, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": true, + "corruption_type": "supporting_hashes", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [ + 0, + 1 + ] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 8, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 6, + "end": 8, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 10, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 11, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 12, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + } + ], + [ + 13, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 14, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 15, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 8, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 9, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 8, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 14, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 14, + "end": 16, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 14, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 14, + "end": 16, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 6, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 10, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 100, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": true, + "corruption_type": "namespace", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": 100, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 8, + "end": 10, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 8, + "end": 8, + "supporting_hashes": [ + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + }, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 6, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 6, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 6, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 14 + } + ], + "corrupted": true, + "corruption_type": "end", + "corruption_diff": { + "changed_start": -1, + "changed_end": 8, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 1, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 4, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 5, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + } + ], + [ + 6, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + } + ], + [ + 7, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 4 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 16 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 18 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 18 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 18 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 16, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 10, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 16, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "generation", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 18 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 18 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 18 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 2, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + }, + { + "minNS": 10, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 16 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 18 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 18 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 18 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 16, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 10, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 16, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 18 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 18 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 18 + } + ], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + }, + { + "proof_v": { + "start": 0, + "end": 2, + "supporting_hashes": [ + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + }, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ] + }, + "tree_v": { + "leaves": { + "#map": [ + [ + 16, + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + } + ], + [ + 17, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + } + ], + [ + 18, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + } + ], + [ + 19, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + } + ], + [ + 20, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + } + ], + [ + 21, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + } + ], + [ + 22, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + } + ], + [ + 23, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + } + ], + [ + 24, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + } + ], + [ + 25, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + } + ], + [ + 26, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + } + ], + [ + 27, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + } + ], + [ + 28, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 16 + } + ], + [ + 29, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 18 + } + ], + [ + 30, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 18 + } + ], + [ + 31, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 18 + } + ] + ] + }, + "hashes": { + "#map": [ + [ + 1, + { + "minNS": 0, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + }, + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 10, + { + "minNS": 4, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 11, + { + "minNS": 8, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 12, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 13, + { + "minNS": 12, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 14, + { + "minNS": 16, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 15, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 16, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + } + ] + } + ], + [ + 17, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 18, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + } + ] + } + ], + [ + 19, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 2, + { + "minNS": 0, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + }, + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 20, + { + "minNS": 4, + "maxNS": 4, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + } + ] + } + ], + [ + 21, + { + "minNS": 6, + "maxNS": 6, + "hash": [ + { + "#tup": [ + "data", + 5 + ] + } + ] + } + ], + [ + 22, + { + "minNS": 8, + "maxNS": 8, + "hash": [ + { + "#tup": [ + "data", + 6 + ] + } + ] + } + ], + [ + 23, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 24, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + } + ] + } + ], + [ + 25, + { + "minNS": 10, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 9 + ] + } + ] + } + ], + [ + 26, + { + "minNS": 12, + "maxNS": 12, + "hash": [ + { + "#tup": [ + "data", + 10 + ] + } + ] + } + ], + [ + 27, + { + "minNS": 14, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 28, + { + "minNS": 16, + "maxNS": 16, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + } + ] + } + ], + [ + 29, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 13 + ] + } + ] + } + ], + [ + 3, + { + "minNS": 10, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + }, + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 30, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 14 + ] + } + ] + } + ], + [ + 31, + { + "minNS": 18, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 4, + { + "minNS": 0, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + }, + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ], + [ + 5, + { + "minNS": 4, + "maxNS": 10, + "hash": [ + { + "#tup": [ + "data", + 4 + ] + }, + { + "#tup": [ + "data", + 5 + ] + }, + { + "#tup": [ + "data", + 6 + ] + }, + { + "#tup": [ + "data", + 7 + ] + } + ] + } + ], + [ + 6, + { + "minNS": 10, + "maxNS": 14, + "hash": [ + { + "#tup": [ + "data", + 8 + ] + }, + { + "#tup": [ + "data", + 9 + ] + }, + { + "#tup": [ + "data", + 10 + ] + }, + { + "#tup": [ + "data", + 11 + ] + } + ] + } + ], + [ + 7, + { + "minNS": 16, + "maxNS": 18, + "hash": [ + { + "#tup": [ + "data", + 12 + ] + }, + { + "#tup": [ + "data", + 13 + ] + }, + { + "#tup": [ + "data", + 14 + ] + }, + { + "#tup": [ + "data", + 15 + ] + } + ] + } + ], + [ + 8, + { + "minNS": 0, + "maxNS": 0, + "hash": [ + { + "#tup": [ + "data", + 0 + ] + }, + { + "#tup": [ + "data", + 1 + ] + } + ] + } + ], + [ + 9, + { + "minNS": 2, + "maxNS": 2, + "hash": [ + { + "#tup": [ + "data", + 2 + ] + }, + { + "#tup": [ + "data", + 3 + ] + } + ] + } + ] + ] + } + }, + "namespace_v": 0, + "state_v": "final", + "leaves_v": [ + { + "value": { + "#tup": [ + "data", + 0 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 1 + ] + }, + "namespaceId": 0 + }, + { + "value": { + "#tup": [ + "data", + 2 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 3 + ] + }, + "namespaceId": 2 + }, + { + "value": { + "#tup": [ + "data", + 4 + ] + }, + "namespaceId": 4 + }, + { + "value": { + "#tup": [ + "data", + 5 + ] + }, + "namespaceId": 6 + }, + { + "value": { + "#tup": [ + "data", + 6 + ] + }, + "namespaceId": 8 + }, + { + "value": { + "#tup": [ + "data", + 7 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 8 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 9 + ] + }, + "namespaceId": 10 + }, + { + "value": { + "#tup": [ + "data", + 10 + ] + }, + "namespaceId": 12 + }, + { + "value": { + "#tup": [ + "data", + 11 + ] + }, + "namespaceId": 14 + }, + { + "value": { + "#tup": [ + "data", + 12 + ] + }, + "namespaceId": 16 + }, + { + "value": { + "#tup": [ + "data", + 13 + ] + }, + "namespaceId": 18 + }, + { + "value": { + "#tup": [ + "data", + 14 + ] + }, + "namespaceId": 18 + }, + { + "value": { + "#tup": [ + "data", + 15 + ] + }, + "namespaceId": 18 + } + ], + "corrupted": true, + "corruption_type": "supporting_hashes", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [ + 0, + 1 + ] + } + }, + { + "proof_v": { + "start": -1, + "end": -1, + "supporting_hashes": [] + }, + "tree_v": { + "leaves": { + "#map": [] + }, + "hashes": { + "#map": [] + } + }, + "namespace_v": -1, + "state_v": "requirements", + "leaves_v": [], + "corrupted": false, + "corruption_type": "", + "corruption_diff": { + "changed_start": -1, + "changed_end": -1, + "changed_namespace": -1, + "changed_indices": [] + } + } + ] +} \ No newline at end of file diff --git a/formal_spec/nmt.qnt b/formal_spec/nmt.qnt index 9864d2e..9de9731 100644 --- a/formal_spec/nmt.qnt +++ b/formal_spec/nmt.qnt @@ -506,7 +506,7 @@ module nmtProofVerification { // step is modelled as a loop of the four always repeating states: // 1) requirements, 2) generation, 3) verification, and 4) final state. // - // 1) when in the "requirements" or "init" state, a random size of the tree and the namespaces + // 1) when in the "requirements" state, a random size of the tree and the namespaces // corresponding to leaves, // are generated and one of the namespaces is chosen to generate a proof for // 2) when in the "generation" state, a proof is generated for the generated tree and the chosen namespace @@ -610,7 +610,7 @@ module nmtTest { // this module iteratively generates a proof and then non-deterministically corrupts it. // run by: - // quint run --main=nmtTest --max-samples=1 --max-steps=100 nmt.qnt --out-itf=ITF_files/out.itf.json + // quint run --main=nmtTest --max-samples=2 --max-steps=100 nmt.qnt --out-itf=ITF_files/out.itf.json // to simulate 100 steps and save output into `out.itf.json`. This output can be used to generate // test cases (eg., in `simulation_test.go`) @@ -632,7 +632,7 @@ module nmtTest { tree_v' = EMPTY_TREE, proof_v' = EMPTY_PROOF, corrupted' = false, - state_v' = "init", + state_v' = "requirements", namespace_v' = -1, leaves_v' = EMPTY_LEAVES, corruption_type' = "", @@ -837,11 +837,11 @@ module nmtTest { } - // step is modelled as by 4 states: + // step is modelled by 4 states: // 1) requirements, 2) generation, 2a) corruptProof, and 3) final state. // // The state `corruptProof` is marked by 2a because it may be skipped (leaving the proof uncorrupted) - // 1) when in the "requirements" or "init" state, a random size of the tree and the namespaces + // 1) when in the "requirements" state, a random size of the tree and the namespaces // corresponding to leaves, // are generated and one of the namespaces is chosen to generate a proof for // 2) when in the "generation" state, a proof is generated for the generated tree and the chosen namespace From f8d85602b09def4ece2245f7bf147587367d5f82 Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Thu, 4 May 2023 17:11:30 +0200 Subject: [PATCH 07/14] formatting go file --- simulation_test.go | 59 +++++++++++++++++++++++----------------------- 1 file changed, 29 insertions(+), 30 deletions(-) diff --git a/simulation_test.go b/simulation_test.go index bb19830..f5d030c 100644 --- a/simulation_test.go +++ b/simulation_test.go @@ -2,7 +2,7 @@ package nmt_test import ( "crypto/sha256" - "io/ioutil" + "os" "testing" "github.com/celestiaorg/nmt" @@ -13,16 +13,17 @@ import ( const nidSize = 2 func getLeavesFromState(state gjson.Result, nidSize int, key string) [][]byte { - itf_leaves := state.Get(key).Array() - var leaves [][]byte + itfLeaves := state.Get(key).Array() - for _, itf_leaf := range itf_leaves { - stateNamespace := int(itf_leaf.Get("namespaceId").Int()) - dataString := itf_leaf.Get("value.#tup.1").String() + leaves := make([][]byte, len(itfLeaves)) + + for idx, itfLeaf := range itfLeaves { + stateNamespace := int(itfLeaf.Get("namespaceId").Int()) + dataString := itfLeaf.Get("value.#tup.1").String() pushData := namespace.PrefixedData(append( intToBytes(stateNamespace, nidSize), []byte(dataString)...)) - leaves = append(leaves, pushData) + leaves[idx] = pushData } return leaves @@ -39,18 +40,18 @@ func checkProof(modelProof gjson.Result, execProof nmt.Proof, nidSize int) bool if modelProofStart != execProofStart || modelProofEnd != execProofEnd { return false } - supporting_hashes := modelProof.Get("supporting_hashes").Array() - if len(supporting_hashes) != len(execProof.Nodes()) { + supportingHashes := modelProof.Get("supporting_hashes").Array() + if len(supportingHashes) != len(execProof.Nodes()) { return false } - for idx, supporting_hash := range supporting_hashes { - modelMinNS := int(supporting_hash.Get("minNS").Int()) + for idx, supportingHash := range supportingHashes { + modelMinNS := int(supportingHash.Get("minNS").Int()) execMinNs := bytesToInt(execProof.Nodes()[idx][:nidSize]) if modelMinNS != execMinNs { return false } - modelMaxNS := int(supporting_hash.Get("maxNS").Int()) + modelMaxNS := int(supportingHash.Get("maxNS").Int()) execMaxNs := bytesToInt(execProof.Nodes()[idx][nidSize:(2 * nidSize)]) if modelMaxNS != execMaxNs { return false @@ -58,7 +59,6 @@ func checkProof(modelProof gjson.Result, execProof nmt.Proof, nidSize int) bool } return true - } func intToBytes(n int, bytesSize int) []byte { @@ -79,12 +79,11 @@ func bytesToInt(bytes []byte) int { } func TestFromITF(t *testing.T) { - var tree *nmt.NamespacedMerkleTree itfFileName := "formal_spec/ITF_files/runTest.itf.json" // itfFileName := "formal_spec/ITF_files/panicIssue.itf.json" - data, err := ioutil.ReadFile(itfFileName) + data, err := os.ReadFile(itfFileName) if err != nil { t.Errorf("Error opening file: %v", err) } @@ -117,10 +116,10 @@ func TestFromITF(t *testing.T) { if err != nil { t.Errorf("Error on prove: %v", err) } - var new_hashes [][]byte + var newHashes [][]byte t.Logf("Proof: %v\n", proof) - var corruption_type string + var corruptionType string if !corrupted { proofMatching := checkProof(modelProof, proof, nidSize) if !proofMatching { @@ -128,14 +127,14 @@ func TestFromITF(t *testing.T) { } } else { // CORRUPTED: now we are modifying the proof to be corrupted here as well - corruption_type = state.Get("corruption_type").String() - t.Log("Corruption type: ", corruption_type) - if corruption_type == "supporting_hashes" { + corruptionType = state.Get("corruption_type").String() + t.Log("Corruption type: ", corruptionType) + if corruptionType == "supporting_hashes" { for idx := 0; idx < len(state.Get("corruption_diff.changed_indices").Array()); idx++ { - new_hashes = append(new_hashes, proof.Nodes()[idx]) + newHashes = append(newHashes, proof.Nodes()[idx]) } } else { - new_hashes = proof.Nodes() + newHashes = proof.Nodes() } // We could examine for different corruption types and then only user `modelProof` for // the corrupted parts of the proof and the rest from the `proof`. The way we do it now, @@ -144,7 +143,7 @@ func TestFromITF(t *testing.T) { proof = nmt.NewInclusionProof( int(modelProof.Get("start").Int()), int(modelProof.Get("end").Int()), - new_hashes, + newHashes, true, ) t.Logf("Corrupted proof: %v\n", proof) @@ -174,7 +173,7 @@ func TestFromITF(t *testing.T) { func TestFromScenario(t *testing.T) { itfFileName := "formal_spec/ITF_files/scenario.json" - data, err := ioutil.ReadFile(itfFileName) + data, err := os.ReadFile(itfFileName) if err != nil { t.Errorf("Error opening file: %v", err) } @@ -183,22 +182,22 @@ func TestFromScenario(t *testing.T) { for _, tt := range tests { states := tt.Get("states").Array() lastState := states[len(states)-1] - namespaceId := int(lastState.Get("namespace_v").Int()) + namespaceID := int(lastState.Get("namespace_v").Int()) - itf_leaves := lastState.Get("leaves_namespace_idx_v").Array() + itfLeaves := lastState.Get("leaves_namespace_idx_v").Array() tree := nmt.New(sha256.New(), nmt.NamespaceIDSize(nidSize)) - for _, itf_leaf := range itf_leaves { - leaf_id := int(itf_leaf.Int()) + for _, itfLeaf := range itfLeaves { + leafID := int(itfLeaf.Int()) pushData := namespace.PrefixedData(append( - intToBytes(leaf_id, nidSize), + intToBytes(leafID, nidSize), []byte("dummy_data")...)) err := tree.Push(pushData) if err != nil { t.Fatalf("invalid test case: %v, error on Push(): %v", tt.Get("name").String(), err) } } - proveNID := intToBytes(namespaceId, nidSize) + proveNID := intToBytes(namespaceID, nidSize) gotProof, err := tree.ProveNamespace(proveNID) if err != nil { t.Fatalf("ProveNamespace() unexpected error: %v", err) From eac197ab65ea624d11d848b2c9fd43af9bb07872 Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Thu, 4 May 2023 17:14:01 +0200 Subject: [PATCH 08/14] linting markdown --- formal_spec/README.md | 47 +++++++++++++++++++++---------------------- 1 file changed, 23 insertions(+), 24 deletions(-) diff --git a/formal_spec/README.md b/formal_spec/README.md index eae1f21..5996614 100644 --- a/formal_spec/README.md +++ b/formal_spec/README.md @@ -1,44 +1,47 @@ The folder `formal_spec` contains a formal specification of the NMT proof/verification logic in [Quint](https://github.com/informalsystems/quint). - # What is Quint? -[Quint](https://github.com/informalsystems/quint) is a specification language, best suited modeling and analyzing distributed systems. +[Quint](https://github.com/informalsystems/quint) is a specification language, best suited modeling and analyzing distributed systems. Quint builds upon Temporal Logic of Actions (TLA) and aims to be easy to learn and use, with state-of-the-art static analysis and development tooling. - The benefits of having a Quint specification are threefold: - - It is a precise description of the expected behavior, and yet it resides on a higher level of abstraction than the code. Furthermore, it is executable, which makes it easier to spot and eliminate mistakes in the specification. Module [nmt](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L253) captures the logic of namespace proof generation and verification, and the invariant [`verificationAlwaysCorrect`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L592) is an example of a property against which a specification can be checked. - - It allows for test generation. Module [`nmtTest`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#LL597C17-L597C17) iteratively generates proofs and non-deterministically corrupts them. These generated test runs are exported in a json format (e.g., file [ITF_traces/runTest.itf.json](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/formal_spec/ITF_files/runTest.itf.json)). To be executed as a part of the standard suite, an adapter [simulation_test.go](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/simulation_test.go) is necessary. (The adapter iterates through the json-represented execution state and translates them to function calls.) The generation of the tests happens through simulation. In that sense, it is similar to the existing tests [fuzz_test.go](https://github.com/celestiaorg/nmt/blob/master/fuzz_test.go), except that it also adds corruption of the data. - - Having specifications written in Quint makes it possible to change tests/specs quickly: either by taking advantage of updates to Quint (e.g., going from simulation to exhaustive checks by changing a command) or by virtue of making changes on the level higher than code (and thus less details need to be changed). + +- It is a precise description of the expected behavior, and yet it resides on a higher level of abstraction than the code. Furthermore, it is executable, which makes it easier to spot and eliminate mistakes in the specification. Module [nmt](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L253) captures the logic of namespace proof generation and verification, and the invariant [`verificationAlwaysCorrect`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L592) is an example of a property against which a specification can be checked. +- It allows for test generation. Module [`nmtTest`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#LL597C17-L597C17) iteratively generates proofs and non-deterministically corrupts them. These generated test runs are exported in a json format (e.g., file [ITF_traces/runTest.itf.json](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/formal_spec/ITF_files/runTest.itf.json)). To be executed as a part of the standard suite, an adapter [simulation_test.go](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/simulation_test.go) is necessary. (The adapter iterates through the json-represented execution state and translates them to function calls.) The generation of the tests happens through simulation. In that sense, it is similar to the existing tests [fuzz_test.go](https://github.com/celestiaorg/nmt/blob/master/fuzz_test.go), except that it also adds corruption of the data. +- Having specifications written in Quint makes it possible to change tests/specs quickly: either by taking advantage of updates to Quint (e.g., going from simulation to exhaustive checks by changing a command) or by virtue of making changes on the level higher than code (and thus less details need to be changed). Current limitations: - - the specification does not model absence proofs - - there is an assumption that every tree is full and complete - - the specification does not model special handling of parity namespace (`ignoreMaxNamespace` option). Modelling it correctly depends on the decision of what the desired behaviour is (issue #148 ) - +- the specification does not model absence proofs +- there is an assumption that every tree is full and complete +- the specification does not model special handling of parity namespace (`ignoreMaxNamespace` option). Modelling it correctly depends on the decision of what the desired behaviour is (issue #148 ) # Intro to Using Quint and the NMT Model ## Installation - - install `quint` tool by running `npm i @informalsystems/quint -g` (more details [here](https://github.com/informalsystems/quint/blob/main/quint/README.md)) - - install the VSCode plugin from [here](https://marketplace.visualstudio.com/items?itemName=informal.quint-vscode). While this is not necessary, it is of great help when writing models. + +- install `quint` tool by running `npm i @informalsystems/quint -g` (more details [here](https://github.com/informalsystems/quint/blob/main/quint/README.md)) +- install the VSCode plugin from [here](https://marketplace.visualstudio.com/items?itemName=informal.quint-vscode). While this is not necessary, it is of great help when writing models. ## Basic resources - - a sequence of very gentle and fun tutorials [here](https://github.com/informalsystems/quint/blob/main/tutorials/README.md) - - language [cheatsheet](https://github.com/informalsystems/quint/blob/main/doc/quint-cheatsheet.pdf) - - documentation for built-in operators [here](https://github.com/informalsystems/quint/blob/main/doc/builtin.md) + +- a sequence of very gentle and fun tutorials [here](https://github.com/informalsystems/quint/blob/main/tutorials/README.md) +- language [cheatsheet](https://github.com/informalsystems/quint/blob/main/doc/quint-cheatsheet.pdf) +- documentation for built-in operators [here](https://github.com/informalsystems/quint/blob/main/doc/builtin.md) ## REPL + After installing the quint tool, run the REPL by typing `quint` to terminal. Then you can play with the REPL by trying some basic expressions, e.g. - - `2+3` - - `val x = Set(1,3,4)` - - `x.powerset()` - - `x.map(i => i*2)` + +- `2+3` +- `val x = Set(1,3,4)` +- `x.powerset()` +- `x.map(i => i*2)` ## Inspecting the NMT model + As a first step, examine the model operators from within REPL. Example commands to try out after running `quint` within the `formal_spec` folder: @@ -81,7 +84,6 @@ step After getting acquainted with all the operators, you can simulate the model behavior by running - - `quint run --main=nmtProofVerification --max-samples=1 --max-steps=100 nmt.qnt --invariant=verificationAlwaysCorrect` This command will run the module `nmtProofVerification`, which iteratively generates data, creates a proof for a namespace and then verifies it. It will run 100 steps of the model and will check that the property `verificationAlwaysCorrect` always holds. It will output the steps to the terminal. (For options, run `quint run --help`) @@ -89,8 +91,5 @@ This command will run the module `nmtProofVerification`, which iteratively gener This command will simulate the module `nmtTest`, which non-deterministically corrupts the generated proof and outputs the simulation steps to the file `ITF_files/out.itf.json`, to be used in tests. ## Running tests -Once a test file is generated, it is read by `simulation_test.go`, a regular go test. (A path to the json file that should be tested needs to be given - at the moment [hardcoded](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/simulation_test.go#L85) in the code.) - - - +Once a test file is generated, it is read by `simulation_test.go`, a regular go test. (A path to the json file that should be tested needs to be given - at the moment [hardcoded](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/simulation_test.go#L85) in the code.) From 5e67a9d5dd1bcf120cc65738ecacad4bbaf086bb Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Fri, 26 May 2023 11:41:09 +0200 Subject: [PATCH 09/14] renamed quint spec folder --- {formal_spec => nmt_quint_model}/ITF_files/panicIssue.itf.json | 0 {formal_spec => nmt_quint_model}/ITF_files/runTest.itf.json | 0 {formal_spec => nmt_quint_model}/ITF_files/scenario.json | 0 {formal_spec => nmt_quint_model}/README.md | 0 {formal_spec => nmt_quint_model}/nmt.qnt | 0 {formal_spec => nmt_quint_model}/tests.qnt | 0 6 files changed, 0 insertions(+), 0 deletions(-) rename {formal_spec => nmt_quint_model}/ITF_files/panicIssue.itf.json (100%) rename {formal_spec => nmt_quint_model}/ITF_files/runTest.itf.json (100%) rename {formal_spec => nmt_quint_model}/ITF_files/scenario.json (100%) rename {formal_spec => nmt_quint_model}/README.md (100%) rename {formal_spec => nmt_quint_model}/nmt.qnt (100%) rename {formal_spec => nmt_quint_model}/tests.qnt (100%) diff --git a/formal_spec/ITF_files/panicIssue.itf.json b/nmt_quint_model/ITF_files/panicIssue.itf.json similarity index 100% rename from formal_spec/ITF_files/panicIssue.itf.json rename to nmt_quint_model/ITF_files/panicIssue.itf.json diff --git a/formal_spec/ITF_files/runTest.itf.json b/nmt_quint_model/ITF_files/runTest.itf.json similarity index 100% rename from formal_spec/ITF_files/runTest.itf.json rename to nmt_quint_model/ITF_files/runTest.itf.json diff --git a/formal_spec/ITF_files/scenario.json b/nmt_quint_model/ITF_files/scenario.json similarity index 100% rename from formal_spec/ITF_files/scenario.json rename to nmt_quint_model/ITF_files/scenario.json diff --git a/formal_spec/README.md b/nmt_quint_model/README.md similarity index 100% rename from formal_spec/README.md rename to nmt_quint_model/README.md diff --git a/formal_spec/nmt.qnt b/nmt_quint_model/nmt.qnt similarity index 100% rename from formal_spec/nmt.qnt rename to nmt_quint_model/nmt.qnt diff --git a/formal_spec/tests.qnt b/nmt_quint_model/tests.qnt similarity index 100% rename from formal_spec/tests.qnt rename to nmt_quint_model/tests.qnt From f52626056a14b22af3533f909920b301ebf9f491 Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Fri, 26 May 2023 11:55:17 +0200 Subject: [PATCH 10/14] typos; parts of renaming that was forgotten --- nmt_quint_model/README.md | 6 +++--- nmt_quint_model/nmt.qnt | 6 +++--- simulation_test.go | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/nmt_quint_model/README.md b/nmt_quint_model/README.md index 5996614..f6a2d9c 100644 --- a/nmt_quint_model/README.md +++ b/nmt_quint_model/README.md @@ -1,7 +1,7 @@ -The folder `formal_spec` contains a formal specification of the NMT proof/verification logic in [Quint](https://github.com/informalsystems/quint). - # What is Quint? +The folder `nmt_quint_model` contains a formal specification of the NMT proof/verification logic in [Quint](https://github.com/informalsystems/quint). + [Quint](https://github.com/informalsystems/quint) is a specification language, best suited modeling and analyzing distributed systems. Quint builds upon Temporal Logic of Actions (TLA) and aims to be easy to learn and use, with state-of-the-art static analysis and development tooling. @@ -45,7 +45,7 @@ Then you can play with the REPL by trying some basic expressions, e.g. As a first step, examine the model operators from within REPL. Example commands to try out after running `quint` within the `formal_spec` folder: -``` +```bluespec .load nmt.qnt import basics.* diff --git a/nmt_quint_model/nmt.qnt b/nmt_quint_model/nmt.qnt index 9de9731..0dd2172 100644 --- a/nmt_quint_model/nmt.qnt +++ b/nmt_quint_model/nmt.qnt @@ -283,7 +283,7 @@ module nmt { // This function creates a proof for a given `namespaceId` and a given `tree`. // Following the NMT documentation (https://github.com/celestiaorg/nmt/blob/master/docs/spec/nmt.md#namespace-proof), - // the tproof consists of `start` and `end` indices and the hashes of the nodes (`supporting_hashes`) that are left siblings + // the proof consists of `start` and `end` indices and the hashes of the nodes (`supporting_hashes`) that are left siblings // in the regular Merkle proof of `start` and those that are right hashes in the regular proof of `end-1` def CreateProofNamespace(namespaceId: int, tree: TREE): PROOF = val leavesStart = min(tree.leaves.keys()) @@ -350,7 +350,7 @@ module nmt { length(elementsWithWrongId) == 0 - // Given `proof` and `leaves`, this function calculates the Merkle roo (which is hash) for that range. + // Given `proof` and `leaves`, this function calculates the Merkle root (which is hash) for that range. def MerkleRangeHash(proof: PROOF, leaves: List[DATA_ITEM]) : WORD = // the number of leaves in a complete subtree that covers the last leaf @@ -610,7 +610,7 @@ module nmtTest { // this module iteratively generates a proof and then non-deterministically corrupts it. // run by: - // quint run --main=nmtTest --max-samples=2 --max-steps=100 nmt.qnt --out-itf=ITF_files/out.itf.json + // quint run --main=nmtTest --max-samples=1 --max-steps=100 nmt.qnt --out-itf=ITF_files/out.itf.json // to simulate 100 steps and save output into `out.itf.json`. This output can be used to generate // test cases (eg., in `simulation_test.go`) diff --git a/simulation_test.go b/simulation_test.go index f5d030c..140e5d9 100644 --- a/simulation_test.go +++ b/simulation_test.go @@ -81,8 +81,8 @@ func bytesToInt(bytes []byte) int { func TestFromITF(t *testing.T) { var tree *nmt.NamespacedMerkleTree - itfFileName := "formal_spec/ITF_files/runTest.itf.json" - // itfFileName := "formal_spec/ITF_files/panicIssue.itf.json" + itfFileName := "nmt_quint_model/ITF_files/runTest.itf.json" + // itfFileName := "nmt_quint_model/ITF_files/panicIssue.itf.json" data, err := os.ReadFile(itfFileName) if err != nil { t.Errorf("Error opening file: %v", err) @@ -172,7 +172,7 @@ func TestFromITF(t *testing.T) { } func TestFromScenario(t *testing.T) { - itfFileName := "formal_spec/ITF_files/scenario.json" + itfFileName := "nmt_quint_model/ITF_files/scenario.json" data, err := os.ReadFile(itfFileName) if err != nil { t.Errorf("Error opening file: %v", err) From c847b877f0d4e5ad978498605c22918d348a599e Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Fri, 26 May 2023 14:19:04 +0200 Subject: [PATCH 11/14] newlines in the markdown file --- nmt_quint_model/README.md | 91 ++++++++++++++++++++++++++++++--------- 1 file changed, 71 insertions(+), 20 deletions(-) diff --git a/nmt_quint_model/README.md b/nmt_quint_model/README.md index f6a2d9c..6b0c90a 100644 --- a/nmt_quint_model/README.md +++ b/nmt_quint_model/README.md @@ -1,34 +1,71 @@ -# What is Quint? +# Intro to Using Quint and the NMT Model + +## What is Quint? -The folder `nmt_quint_model` contains a formal specification of the NMT proof/verification logic in [Quint](https://github.com/informalsystems/quint). +The folder `nmt_quint_model` contains a formal specification of the NMT +proof/verification logic in [Quint](https://github.com/informalsystems/quint). -[Quint](https://github.com/informalsystems/quint) is a specification language, best suited modeling and analyzing distributed systems. -Quint builds upon Temporal Logic of Actions (TLA) and aims to be easy to learn and use, with state-of-the-art static analysis and development tooling. +[Quint](https://github.com/informalsystems/quint) is a specification language, +best suited modeling and analyzing distributed systems. +Quint builds upon Temporal Logic of Actions (TLA) and aims to be easy to +learn and use, with state-of-the-art static analysis and development tooling. The benefits of having a Quint specification are threefold: -- It is a precise description of the expected behavior, and yet it resides on a higher level of abstraction than the code. Furthermore, it is executable, which makes it easier to spot and eliminate mistakes in the specification. Module [nmt](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L253) captures the logic of namespace proof generation and verification, and the invariant [`verificationAlwaysCorrect`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L592) is an example of a property against which a specification can be checked. -- It allows for test generation. Module [`nmtTest`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#LL597C17-L597C17) iteratively generates proofs and non-deterministically corrupts them. These generated test runs are exported in a json format (e.g., file [ITF_traces/runTest.itf.json](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/formal_spec/ITF_files/runTest.itf.json)). To be executed as a part of the standard suite, an adapter [simulation_test.go](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/simulation_test.go) is necessary. (The adapter iterates through the json-represented execution state and translates them to function calls.) The generation of the tests happens through simulation. In that sense, it is similar to the existing tests [fuzz_test.go](https://github.com/celestiaorg/nmt/blob/master/fuzz_test.go), except that it also adds corruption of the data. -- Having specifications written in Quint makes it possible to change tests/specs quickly: either by taking advantage of updates to Quint (e.g., going from simulation to exhaustive checks by changing a command) or by virtue of making changes on the level higher than code (and thus less details need to be changed). +- It is a precise description of the expected behavior, +and yet it resides on a higher level of abstraction than the code. +Furthermore, it is executable, which makes it easier to spot and +eliminate mistakes in the specification. +Module [nmt](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L253) +captures the logic of namespace proof generation and verification, +and the invariant +[`verificationAlwaysCorrect`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L592) +is an example of a property against which a specification can be checked. +- It allows for test generation. +Module [`nmtTest`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#LL597C17-L597C17) +iteratively generates proofs and non-deterministically corrupts them. +These generated test runs are exported in a json format +(e.g., file [ITF_traces/runTest.itf.json](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/formal_spec/ITF_files/runTest.itf.json)). +To be executed as a part of the standard suite, an adapter +[simulation_test.go](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/simulation_test.go) +is necessary. +(The adapter iterates through the json-represented execution state and +translates them to function calls.) +The generation of the tests happens through simulation. +In that sense, it is similar to the existing tests +[fuzz_test.go](https://github.com/celestiaorg/nmt/blob/master/fuzz_test.go), +except that it also adds corruption of the data. +- Having specifications written in Quint makes it possible to change +tests/specs quickly: +either by taking advantage of updates to Quint +(e.g., going from simulation to exhaustive checks by changing a command) +or by virtue of making changes on the level higher than code +(and thus less details need to be changed). Current limitations: - the specification does not model absence proofs - there is an assumption that every tree is full and complete -- the specification does not model special handling of parity namespace (`ignoreMaxNamespace` option). Modelling it correctly depends on the decision of what the desired behaviour is (issue #148 ) - -# Intro to Using Quint and the NMT Model +- the specification does not model special handling of parity namespace +(`ignoreMaxNamespace` option). +Modelling it correctly depends on the decision of what the desired +behaviour is (issue #148 ) ## Installation -- install `quint` tool by running `npm i @informalsystems/quint -g` (more details [here](https://github.com/informalsystems/quint/blob/main/quint/README.md)) -- install the VSCode plugin from [here](https://marketplace.visualstudio.com/items?itemName=informal.quint-vscode). While this is not necessary, it is of great help when writing models. +- install `quint` tool by running `npm i @informalsystems/quint -g` +(more details [here](https://github.com/informalsystems/quint/blob/main/quint/README.md)) +- install the VSCode plugin from +[here](https://marketplace.visualstudio.com/items?itemName=informal.quint-vscode). +While this is not necessary, it is of great help when writing models. ## Basic resources -- a sequence of very gentle and fun tutorials [here](https://github.com/informalsystems/quint/blob/main/tutorials/README.md) +- a sequence of very gentle and fun tutorials +[here](https://github.com/informalsystems/quint/blob/main/tutorials/README.md) - language [cheatsheet](https://github.com/informalsystems/quint/blob/main/doc/quint-cheatsheet.pdf) -- documentation for built-in operators [here](https://github.com/informalsystems/quint/blob/main/doc/builtin.md) +- documentation for built-in operators +[here](https://github.com/informalsystems/quint/blob/main/doc/builtin.md) ## REPL @@ -82,14 +119,28 @@ step step ``` -After getting acquainted with all the operators, you can simulate the model behavior by running +After getting acquainted with all the operators, +you can simulate the model behavior by running -- `quint run --main=nmtProofVerification --max-samples=1 --max-steps=100 nmt.qnt --invariant=verificationAlwaysCorrect` -This command will run the module `nmtProofVerification`, which iteratively generates data, creates a proof for a namespace and then verifies it. It will run 100 steps of the model and will check that the property `verificationAlwaysCorrect` always holds. It will output the steps to the terminal. (For options, run `quint run --help`) +- `quint run --main=nmtProofVerification --max-samples=1 --max-steps=100 nmt.qnt --invariant=verificationAlwaysCorrect`. +This command will run the module `nmtProofVerification`, +which iteratively generates data, +creates a proof for a namespace and then verifies it. +It will run 100 steps of the model and will check +that the property `verificationAlwaysCorrect` always holds. +It will output the steps to the terminal. +(For options, run `quint run --help`) -- `quint run --main=nmtTest --max-samples=1 --max-steps=100 nmt.qnt --out-itf=ITF_files/out.itf.json` -This command will simulate the module `nmtTest`, which non-deterministically corrupts the generated proof and outputs the simulation steps to the file `ITF_files/out.itf.json`, to be used in tests. +- `quint run --main=nmtTest --max-samples=1 --max-steps=100 nmt.qnt --out-itf=ITF_files/out.itf.json`. +This command will simulate the module `nmtTest`, +which non-deterministically corrupts the generated proof +and outputs the simulation steps to the file `ITF_files/out.itf.json`, +to be used in tests. ## Running tests -Once a test file is generated, it is read by `simulation_test.go`, a regular go test. (A path to the json file that should be tested needs to be given - at the moment [hardcoded](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/simulation_test.go#L85) in the code.) +Once a test file is generated, it is read by `simulation_test.go`, +a regular go test. +(A path to the json file that should be tested needs to be given - +at the moment +[hardcoded](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/simulation_test.go#L85).) From 0991bd010f0c4cb9e3d21aab677b008c8ff761ec Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Fri, 26 May 2023 14:30:43 +0200 Subject: [PATCH 12/14] fixing links with absolute paths --- nmt_quint_model/README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/nmt_quint_model/README.md b/nmt_quint_model/README.md index 6b0c90a..ed5d648 100644 --- a/nmt_quint_model/README.md +++ b/nmt_quint_model/README.md @@ -16,18 +16,18 @@ The benefits of having a Quint specification are threefold: and yet it resides on a higher level of abstraction than the code. Furthermore, it is executable, which makes it easier to spot and eliminate mistakes in the specification. -Module [nmt](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L253) +Module [nmt](../nmt_quint_model/nmt.qnt#L253) captures the logic of namespace proof generation and verification, and the invariant -[`verificationAlwaysCorrect`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#L592) +[`verificationAlwaysCorrect`](../nmt_quint_model/nmt.qnt#L592) is an example of a property against which a specification can be checked. - It allows for test generation. -Module [`nmtTest`](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/formal_spec/nmt.qnt#LL597C17-L597C17) +Module [`nmtTest`](../nmt_quint_model/nmt.qnt#LL597C17-L597C17) iteratively generates proofs and non-deterministically corrupts them. These generated test runs are exported in a json format -(e.g., file [ITF_traces/runTest.itf.json](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/formal_spec/ITF_files/runTest.itf.json)). +(e.g., file [ITF_traces/runTest.itf.json](../nmt_quint_model/ITF_files/runTest.itf.json)). To be executed as a part of the standard suite, an adapter -[simulation_test.go](https://github.com/ivan-gavran/nmt/blob/ivan/quint_spec/simulation_test.go) +[simulation_test.go](../nmt_quint_model/simulation_test.go) is necessary. (The adapter iterates through the json-represented execution state and translates them to function calls.) @@ -143,4 +143,4 @@ Once a test file is generated, it is read by `simulation_test.go`, a regular go test. (A path to the json file that should be tested needs to be given - at the moment -[hardcoded](https://github.com/ivan-gavran/nmt/blob/c3cc6b7acba34c97a1a4d5e8fa4be1d355535c1e/simulation_test.go#L85).) +[hardcoded](../simulation_test.go#L84).) From 6b9aac3dc6b7991a60ffbbfefb431ae500012546 Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Fri, 26 May 2023 14:41:22 +0200 Subject: [PATCH 13/14] another broken link fixed --- nmt_quint_model/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nmt_quint_model/README.md b/nmt_quint_model/README.md index ed5d648..aa820e8 100644 --- a/nmt_quint_model/README.md +++ b/nmt_quint_model/README.md @@ -27,7 +27,7 @@ iteratively generates proofs and non-deterministically corrupts them. These generated test runs are exported in a json format (e.g., file [ITF_traces/runTest.itf.json](../nmt_quint_model/ITF_files/runTest.itf.json)). To be executed as a part of the standard suite, an adapter -[simulation_test.go](../nmt_quint_model/simulation_test.go) +[simulation_test.go](../simulation_test.go) is necessary. (The adapter iterates through the json-represented execution state and translates them to function calls.) From 292a2c1b7555aeef29dea8df6ddc73a4e8d7f11b Mon Sep 17 00:00:00 2001 From: ivan-gavran Date: Fri, 26 May 2023 14:52:39 +0200 Subject: [PATCH 14/14] typo --- nmt_quint_model/nmt.qnt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nmt_quint_model/nmt.qnt b/nmt_quint_model/nmt.qnt index 0dd2172..be96ef0 100644 --- a/nmt_quint_model/nmt.qnt +++ b/nmt_quint_model/nmt.qnt @@ -768,7 +768,7 @@ module nmtTest { proof_v.supporting_hashes.length() > 1, namespace_v' = namespace_v, // We use the original set of indices and then take a subset of it as a corrupted one. - // We do so by selecting `oneOf` from the set of all subsets of existing indices (`powerse`), + // We do so by selecting `oneOf` from the set of all subsets of existing indices (`powerset`), // provided that it is not the empty set and not the full set of indices. (`filter`). // Note that this is non-deterministic value (`nondet`) because of the function `oneOf`. nondet new_supporting_hashes_indices = oneOf(