+29 -8

abciapp/app.go

··· 9 9 10 10 dbm "github.com/cometbft/cometbft-db" 11 11 abcitypes "github.com/cometbft/cometbft/abci/types" 12 12 + bftstore "github.com/cometbft/cometbft/store" 13 13 + "github.com/cometbft/cometbft/types" 12 14 "github.com/cosmos/iavl" 13 15 "github.com/klauspost/compress/zstd" 14 16 "github.com/palantir/stacktrace" ··· 28 30 tree *iavl.MutableTree 29 31 fullyClearApplicationData func() error 30 32 33 33 + privValidator types.PrivValidator 34 34 + 31 35 ongoingRead transaction.Read 32 36 ongoingWrite transaction.Write 33 37 ··· 38 42 lastProcessedProposalExecTxResults []*processResult 39 43 40 44 aocsByPLC map[string]*authoritativeOperationsCache 45 45 + 46 46 + blockChallengeCoordinator *blockChallengeCoordinator 41 47 } 42 48 43 49 // store and plc must be able to share transaction objects 44 44 - func NewDIDPLCApplication(treeDB dbm.DB, indexDB transaction.ExtendedDB, clearData func(), snapshotDirectory, didBloomFilterPath string) (*DIDPLCApplication, *transaction.Factory, plc.PLC, func(), error) { 50 50 + func NewDIDPLCApplication(pv types.PrivValidator, treeDB dbm.DB, indexDB transaction.ExtendedDB, clearData func(), snapshotDirectory, didBloomFilterPath string) (*DIDPLCApplication, *transaction.Factory, plc.PLC, func(), error) { 45 51 mkTree := func() *iavl.MutableTree { 46 52 // Using SpeedDefault appears to cause the processing time for ExecuteOperation to double on average 47 53 // Using SpeedBetterCompression appears to cause the processing time to double again ··· 62 68 return nil, nil, nil, func() {}, stacktrace.Propagate(err, "") 63 69 } 64 70 } 71 71 + 72 72 + runnerContext, cancelRunnerContext := context.WithCancel(context.Background()) 65 73 66 74 d := &DIDPLCApplication{ 67 67 - runnerContext: context.Background(), 75 75 + runnerContext: runnerContext, 76 76 + privValidator: pv, 68 77 tree: tree, 69 78 indexDB: indexDB, 70 79 snapshotDirectory: snapshotDirectory, 71 80 aocsByPLC: make(map[string]*authoritativeOperationsCache), 72 81 } 73 82 74 74 - d.txFactory, err = transaction.NewFactory(tree, indexDB, store.Consensus.NextOperationSequence, store.NewDIDBloomFilterStore(didBloomFilterPath)) 83 83 + d.txFactory, err = transaction.NewFactory(tree, indexDB, store.Consensus.CountOperations, store.NewDIDBloomFilterStore(didBloomFilterPath)) 75 84 if err != nil { 76 76 - return nil, nil, nil, func() {}, stacktrace.Propagate(err, "") 85 85 + return nil, nil, nil, cancelRunnerContext, stacktrace.Propagate(err, "") 77 86 } 78 87 79 88 d.fullyClearApplicationData = func() error { ··· 88 97 89 98 *d.tree = *mkTree() 90 99 91 91 - d.txFactory, err = transaction.NewFactory(tree, indexDB, store.Consensus.NextOperationSequence, store.NewDIDBloomFilterStore(didBloomFilterPath)) 100 100 + d.txFactory, err = transaction.NewFactory(tree, indexDB, store.Consensus.CountOperations, store.NewDIDBloomFilterStore(didBloomFilterPath)) 92 101 if err != nil { 93 102 return stacktrace.Propagate(err, "") 94 103 } ··· 98 107 d.plc = plc.NewPLC() 99 108 100 109 var wg sync.WaitGroup 101 101 - closeCh := make(chan struct{}) 102 110 wg.Go(func() { 103 111 // periodically store bloom filter so we don't have to wait so long on the next startup 104 112 for { 105 113 select { 106 106 - case <-closeCh: 114 114 + case <-runnerContext.Done(): 107 115 return 108 116 case <-time.After(5 * time.Minute): 109 117 } ··· 169 177 */ 170 178 171 179 return d, d.txFactory, d.plc, func() { 172 172 - close(closeCh) 180 180 + cancelRunnerContext() 173 181 wg.Wait() 174 182 lo.Must0(d.tree.Close()) 175 183 }, nil 184 184 + } 185 185 + 186 186 + func (d *DIDPLCApplication) FinishInitializing(blockStore *bftstore.BlockStore) error { 187 187 + pubKey, err := d.privValidator.GetPubKey() 188 188 + if err != nil { 189 189 + return stacktrace.Propagate(err, "") 190 190 + } 191 191 + 192 192 + d.blockChallengeCoordinator, err = newBlockChallengeCoordinator(d.runnerContext, d.txFactory, blockStore, pubKey) 193 193 + if err != nil { 194 194 + return stacktrace.Propagate(err, "") 195 195 + } 196 196 + return nil 176 197 } 177 198 178 199 var _ abcitypes.Application = (*DIDPLCApplication)(nil)

+1 -1

abciapp/app_test.go

··· 22 22 } 23 23 24 24 func TestCheckTx(t *testing.T) { 25 25 - app, _, _, cleanup, err := abciapp.NewDIDPLCApplication(dbm.NewMemDB(), memDBWrapper{dbm.NewMemDB()}, nil, "", "") 25 25 + app, _, _, cleanup, err := abciapp.NewDIDPLCApplication(nil, dbm.NewMemDB(), memDBWrapper{dbm.NewMemDB()}, nil, "", "") 26 26 require.NoError(t, err) 27 27 t.Cleanup(cleanup) 28 28

+320

abciapp/block_challenge.go

··· 1 1 + package abciapp 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "context" 6 6 + "embed" 7 7 + "fmt" 8 8 + "math/big" 9 9 + "time" 10 10 + 11 11 + "github.com/Yiling-J/theine-go" 12 12 + "github.com/cometbft/cometbft/crypto" 13 13 + bftstore "github.com/cometbft/cometbft/store" 14 14 + "github.com/consensys/gnark-crypto/ecc" 15 15 + "github.com/consensys/gnark-crypto/ecc/bn254" 16 16 + "github.com/consensys/gnark-crypto/ecc/bn254/fr/mimc" 17 17 + "github.com/consensys/gnark/backend" 18 18 + "github.com/consensys/gnark/backend/groth16" 19 19 + "github.com/consensys/gnark/backend/witness" 20 20 + "github.com/consensys/gnark/constraint" 21 21 + "github.com/consensys/gnark/constraint/solver" 22 22 + "github.com/consensys/gnark/frontend" 23 23 + "github.com/palantir/stacktrace" 24 24 + "github.com/rs/zerolog" 25 25 + "github.com/samber/lo" 26 26 + "resenje.org/singleflight" 27 27 + "tangled.org/gbl08ma.com/didplcbft/proof" 28 28 + "tangled.org/gbl08ma.com/didplcbft/store" 29 29 + "tangled.org/gbl08ma.com/didplcbft/transaction" 30 30 + ) 31 31 + 32 32 + //go:embed proofcircuit/BlockChallenge_* 33 33 + var blockChallengeCircuitFS embed.FS 34 34 + 35 35 + var blockChallengeConstraintSystem constraint.ConstraintSystem 36 36 + var blockChallengeProvingKey groth16.ProvingKey 37 37 + var blockChallengeVerifyingKey groth16.VerifyingKey 38 38 + 39 39 + func init() { 40 40 + blockChallengeConstraintSystem = groth16.NewCS(ecc.BN254) 41 41 + csFile := lo.Must(blockChallengeCircuitFS.Open("proofcircuit/BlockChallenge_ConstraintSystem")) 42 42 + defer csFile.Close() 43 43 + lo.Must(blockChallengeConstraintSystem.ReadFrom(csFile)) 44 44 + 45 45 + blockChallengeProvingKey = groth16.NewProvingKey(ecc.BN254) 46 46 + pkFile := lo.Must(blockChallengeCircuitFS.Open("proofcircuit/BlockChallenge_ProvingKey")) 47 47 + defer pkFile.Close() 48 48 + lo.Must(blockChallengeProvingKey.ReadFrom(pkFile)) 49 49 + 50 50 + blockChallengeVerifyingKey = groth16.NewVerifyingKey(ecc.BN254) 51 51 + vkFile := lo.Must(blockChallengeCircuitFS.Open("proofcircuit/BlockChallenge_VerifyingKey")) 52 52 + defer vkFile.Close() 53 53 + lo.Must(blockChallengeVerifyingKey.ReadFrom(vkFile)) 54 54 + } 55 55 + 56 56 + type blockChallengeCoordinator struct { 57 57 + g singleflight.Group[int64, []byte] 58 58 + 59 59 + runnerContext context.Context 60 60 + 61 61 + validatorAddress []byte 62 62 + txFactory *transaction.Factory 63 63 + nodeBlockStore *bftstore.BlockStore 64 64 + 65 65 + sharedWitnessDataCache *theine.LoadingCache[int64, proof.BlockChallengeCircuit] 66 66 + } 67 67 + 68 68 + func newBlockChallengeCoordinator(runnerContext context.Context, txFactory *transaction.Factory, blockStore *bftstore.BlockStore, pubKey crypto.PubKey) (*blockChallengeCoordinator, error) { 69 69 + c := &blockChallengeCoordinator{ 70 70 + runnerContext: runnerContext, 71 71 + txFactory: txFactory, 72 72 + nodeBlockStore: blockStore, 73 73 + validatorAddress: pubKey.Address(), 74 74 + } 75 75 + 76 76 + var err error 77 77 + c.sharedWitnessDataCache, err = theine.NewBuilder[int64, proof.BlockChallengeCircuit](5). 78 78 + Loading( 79 79 + func(ctx context.Context, height int64) (theine.Loaded[proof.BlockChallengeCircuit], error) { 80 80 + var zeroValue theine.Loaded[proof.BlockChallengeCircuit] 81 81 + 82 82 + anyTx := ctx.Value(contextTxKey{}) 83 83 + if anyTx == nil { 84 84 + return theine.Loaded[proof.BlockChallengeCircuit]{}, stacktrace.NewError("transaction not found in context") 85 85 + } 86 86 + tx, ok := anyTx.(transaction.Read) 87 87 + if !ok { 88 88 + return zeroValue, stacktrace.NewError("invalid transaction in context") 89 89 + } 90 90 + 91 91 + operationData, lastCommitHash, err := c.blockChallengeOperationDataForHeight(tx, height) 92 92 + if err != nil { 93 93 + return zeroValue, stacktrace.Propagate(err, "") 94 94 + } 95 95 + 96 96 + sharedPart := buildBlockChallengeCircuitAssignmentShared(lastCommitHash, [1550]byte(operationData)) 97 97 + 98 98 + return theine.Loaded[proof.BlockChallengeCircuit]{ 99 99 + Value: sharedPart, 100 100 + }, nil 101 101 + }).Build() 102 102 + if err != nil { 103 103 + return nil, stacktrace.Propagate(err, "") 104 104 + } 105 105 + 106 106 + return c, nil 107 107 + } 108 108 + 109 109 + type contextTxKey struct{} 110 110 + 111 111 + // in challengeManager method arguments, `height` is always the height of the "current" block C which uses data from block C-1: 112 112 + // - the consensus tree from block C-1 113 113 + // - the lastCommitHash from block C-1 114 114 + // to solve/prove the challenge for block C, which gets stored as the challenge for block C 115 115 + // C might be the height of the block that is currently still being prepared/proposed/voted on 116 116 + // the proofs should be stable regardless of how many proposal rounds we go through, because they only use data from C-1 117 117 + 118 118 + func (c *blockChallengeCoordinator) notifyOfIncomingBlockHeight(height int64) { 119 119 + go func() { 120 120 + _, err := c.loadOrComputeBlockChallengeProof(c.runnerContext, height) 121 121 + if err != nil { 122 122 + fmt.Printf("FAILED TO COMPUTE CHALLENGE FOR BLOCK %d: %v\n", height, stacktrace.Propagate(err, "")) 123 123 + } 124 124 + }() 125 125 + } 126 126 + 127 127 + func (c *blockChallengeCoordinator) loadOrComputeBlockChallengeProof(ctx context.Context, height int64) ([]byte, error) { 128 128 + proof, _, err := c.g.Do(ctx, height, func(ctx context.Context) ([]byte, error) { 129 129 + // we need to read the tree as it was on the block prior. We assume that this method will only be called in the processing of the latest block 130 130 + // and we validate this assumption 131 131 + tx := c.txFactory.ReadCommitted() 132 132 + if tx.Height() != height-1 { 133 133 + return nil, stacktrace.NewError("challenge being loaded or computed for unexpected height %d, expected %d", height, tx.Height()+1) 134 134 + } 135 135 + 136 136 + proof, err := store.Consensus.BlockChallengeProof(tx, uint64(height)) 137 137 + if err != nil { 138 138 + return nil, stacktrace.Propagate(err, "") 139 139 + } 140 140 + if proof == nil { 141 141 + // compute and store 142 142 + proof, err = c.computeBlockChallengeProof(tx, height) 143 143 + if err != nil { 144 144 + return nil, stacktrace.Propagate(err, "") 145 145 + } 146 146 + 147 147 + wtx, err := tx.UpgradeForIndexOnly() 148 148 + if err != nil { 149 149 + return nil, stacktrace.Propagate(err, "") 150 150 + } 151 151 + defer wtx.Rollback() 152 152 + 153 153 + err = store.Consensus.StoreBlockChallengeProof(ctx, wtx, uint64(height), proof) 154 154 + if err != nil { 155 155 + return nil, stacktrace.Propagate(err, "") 156 156 + } 157 157 + 158 158 + err = wtx.Commit() 159 159 + if err != nil { 160 160 + return nil, stacktrace.Propagate(err, "") 161 161 + } 162 162 + } 163 163 + return proof, nil 164 164 + }) 165 165 + return proof, stacktrace.Propagate(err, "") 166 166 + } 167 167 + 168 168 + func (c *blockChallengeCoordinator) computeBlockChallengeProof(tx transaction.Read, height int64) ([]byte, error) { 169 169 + st := time.Now() 170 170 + 171 171 + witness, err := c.buildPrivateChallengeWitnessForHeight(tx, height) 172 172 + if err != nil { 173 173 + return nil, stacktrace.Propagate(err, "") 174 174 + } 175 175 + 176 176 + // TODO consider using a different logger once we clean up our logging act 177 177 + // TODO open an issue in the gnark repo because backend.WithSolverOptions(solver.WithLogger(zerolog.Nop())) has no effect... 178 178 + proof, err := groth16.Prove(blockChallengeConstraintSystem, blockChallengeProvingKey, witness, backend.WithSolverOptions(solver.WithLogger(zerolog.Nop()))) 179 179 + if err != nil { 180 180 + return nil, stacktrace.Propagate(err, "") 181 181 + } 182 182 + 183 183 + buf := new(bytes.Buffer) 184 184 + 185 185 + _, err = proof.WriteTo(buf) 186 186 + if err != nil { 187 187 + return nil, stacktrace.Propagate(err, "") 188 188 + } 189 189 + 190 190 + fmt.Println("COMPUTED CHALLENGE FOR BLOCK", height, "IN", time.Since(st), "SIZE", buf.Len(), "BYTES") 191 191 + 192 192 + return buf.Bytes(), nil 193 193 + } 194 194 + 195 195 + func (c *blockChallengeCoordinator) verifyBlockChallengeProof(height int64, validatorAddress []byte, proofBytes []byte) (bool, error) { 196 196 + tx := c.txFactory.ReadCommitted() 197 197 + if tx.Height() != height-1 { 198 198 + return false, stacktrace.NewError("challenge being verified for unexpected height %d, expected %d", height, tx.Height()+1) 199 199 + } 200 200 + 201 201 + sharedPart, err := c.fetchOrBuildBlockChallengeCircuitAssignmentShared(tx, height) 202 202 + if err != nil { 203 203 + return false, stacktrace.Propagate(err, "") 204 204 + } 205 205 + 206 206 + assignment := buildBlockChallengeCircuitAssignmentFull(sharedPart, validatorAddress) 207 207 + 208 208 + witness, err := frontend.NewWitness(assignment, bn254.ID.ScalarField()) 209 209 + if err != nil { 210 210 + return false, stacktrace.Propagate(err, "") 211 211 + } 212 212 + 213 213 + publicWitness, err := witness.Public() 214 214 + if err != nil { 215 215 + return false, stacktrace.Propagate(err, "") 216 216 + } 217 217 + 218 218 + proof := groth16.NewProof(bn254.ID) 219 219 + 220 220 + _, err = proof.ReadFrom(bytes.NewBuffer(proofBytes)) 221 221 + if err != nil { 222 222 + return false, stacktrace.Propagate(err, "") 223 223 + } 224 224 + 225 225 + err = groth16.Verify(proof, blockChallengeVerifyingKey, publicWitness) 226 226 + return err == nil, nil 227 227 + } 228 228 + 229 229 + func (c *blockChallengeCoordinator) buildPrivateChallengeWitnessForHeight(tx transaction.Read, height int64) (witness.Witness, error) { 230 230 + sharedPart, err := c.fetchOrBuildBlockChallengeCircuitAssignmentShared(tx, height) 231 231 + if err != nil { 232 232 + return nil, stacktrace.Propagate(err, "") 233 233 + } 234 234 + 235 235 + assignment := buildBlockChallengeCircuitAssignmentFull(sharedPart, c.validatorAddress) 236 236 + 237 237 + witness, err := frontend.NewWitness(assignment, bn254.ID.ScalarField()) 238 238 + return witness, stacktrace.Propagate(err, "") 239 239 + } 240 240 + 241 241 + func (c *blockChallengeCoordinator) blockChallengeOperationDataForHeight(tx transaction.Read, height int64) ([]byte, []byte, error) { 242 242 + if height <= 1 { 243 243 + return make([]byte, proof.OperationDataLength), make([]byte, 32), nil 244 244 + } 245 245 + lastBlock := c.nodeBlockStore.LoadBlock(height - 1) 246 246 + if lastBlock == nil { 247 247 + return nil, nil, stacktrace.NewError("height not found") 248 248 + } 249 249 + 250 250 + lastCommitHash := lastBlock.LastCommitHash 251 251 + lastCommitHashBigInt := big.NewInt(0).SetBytes(lastCommitHash) 252 252 + 253 253 + highestOp, err := tx.CountOperations() 254 254 + if err != nil { 255 255 + return nil, nil, stacktrace.Propagate(err, "") 256 256 + } 257 257 + 258 258 + initialOpDataLen := proof.OperationDataLength + int(lastCommitHash[0]) 259 259 + operationData := make([]byte, initialOpDataLen) 260 260 + operationDataCursor := 0 261 261 + if highestOp > 0 { 262 262 + startOpIdxBigInt := big.NewInt(0).Mod(lastCommitHashBigInt, big.NewInt(0).SetUint64(highestOp-1)) 263 263 + startOpIdx := startOpIdxBigInt.Uint64() 264 264 + // the starting operation sequence is startOpIdx+1 265 265 + // because operations sequences start at 1 but the result of the modulus is (0, n( 266 266 + // but that's ok because the OperationsIterator cursor parameter is "after" (i.e. the lower bound is exclusive) 267 267 + // so we indeed want a 0-indexed parameter 268 268 + for _, rawOpValue := range store.Consensus.OperationsIterator(tx, startOpIdx, &err) { 269 269 + operationDataCursor += copy(operationData[operationDataCursor:], rawOpValue) 270 270 + if operationDataCursor >= initialOpDataLen { 271 271 + break 272 272 + } 273 273 + } 274 274 + if err != nil { 275 275 + return nil, nil, stacktrace.Propagate(err, "") 276 276 + } 277 277 + } 278 278 + 279 279 + return operationData[lastCommitHash[0]:], lastBlock.LastCommitHash, nil 280 280 + } 281 281 + 282 282 + func (c *blockChallengeCoordinator) fetchOrBuildBlockChallengeCircuitAssignmentShared(tx transaction.Read, height int64) (proof.BlockChallengeCircuit, error) { 283 283 + ctx := context.WithValue(c.runnerContext, contextTxKey{}, tx) 284 284 + v, err := c.sharedWitnessDataCache.Get(ctx, height) 285 285 + return v, stacktrace.Propagate(err, "") 286 286 + } 287 287 + 288 288 + func buildBlockChallengeCircuitAssignmentShared(lastCommitHash []byte, data [1550]byte) proof.BlockChallengeCircuit { 289 289 + var assignment proof.BlockChallengeCircuit 290 290 + 291 291 + h := mimc.NewMiMC() 292 292 + 293 293 + if len(lastCommitHash) > 31 { 294 294 + lastCommitHash = lastCommitHash[len(lastCommitHash)-31:] 295 295 + } 296 296 + h.Write(lastCommitHash) 297 297 + assignment.LastCommitHash = lastCommitHash 298 298 + 299 299 + for i := 0; i < len(assignment.OperationData); i++ { 300 300 + d := data[31*i : 31*(i+1)] 301 301 + assignment.OperationData[i] = d 302 302 + h.Write(d) 303 303 + } 304 304 + 305 305 + sharedHash := h.Sum(nil) 306 306 + assignment.SharedHash = sharedHash 307 307 + return assignment 308 308 + } 309 309 + 310 310 + func buildBlockChallengeCircuitAssignmentFull(shared proof.BlockChallengeCircuit, validatorAddress []byte) *proof.BlockChallengeCircuit { 311 311 + h := mimc.NewMiMC() 312 312 + 313 313 + h.Write(validatorAddress) 314 314 + h.Write(shared.SharedHash.([]byte)) 315 315 + 316 316 + shared.ValidatorAddress = validatorAddress 317 317 + shared.SpecificHash = h.Sum(nil) 318 318 + 319 319 + return &shared 320 320 + }

+31 -9

abciapp/execution.go

··· 16 16 ) 17 17 18 18 // InitChain implements [types.Application]. 19 19 - func (d *DIDPLCApplication) InitChain(context.Context, *abcitypes.RequestInitChain) (*abcitypes.ResponseInitChain, error) { 20 20 - // TODO 21 21 - return &abcitypes.ResponseInitChain{}, nil 19 19 + func (d *DIDPLCApplication) InitChain(_ context.Context, req *abcitypes.RequestInitChain) (*abcitypes.ResponseInitChain, error) { 20 20 + req.ConsensusParams.Abci.VoteExtensionsEnableHeight = 1 21 21 + return &abcitypes.ResponseInitChain{ 22 22 + ConsensusParams: req.ConsensusParams, 23 23 + }, nil 22 24 } 23 25 24 26 // PrepareProposal implements [types.Application]. ··· 124 126 } 125 127 }() 126 128 129 129 + if d.privValidator != nil { 130 130 + d.blockChallengeCoordinator.notifyOfIncomingBlockHeight(req.Height) 131 131 + } 132 132 + 127 133 txResults := make([]*processResult, len(req.Txs)) 128 134 for i, tx := range req.Txs { 129 135 result, action, processor, err := beginProcessTx(tx) ··· 160 166 } 161 167 162 168 // ExtendVote implements [types.Application]. 163 163 - func (d *DIDPLCApplication) ExtendVote(context.Context, *abcitypes.RequestExtendVote) (*abcitypes.ResponseExtendVote, error) { 164 164 - // TODO 165 165 - return &abcitypes.ResponseExtendVote{}, nil 169 169 + func (d *DIDPLCApplication) ExtendVote(ctx context.Context, req *abcitypes.RequestExtendVote) (*abcitypes.ResponseExtendVote, error) { 170 170 + if d.privValidator == nil { 171 171 + // we are not meant to be performing validator duties... 172 172 + return nil, stacktrace.NewError("unexpected ExtendVote call: node is not configured to be a validator") 173 173 + } 174 174 + 175 175 + proof, err := d.blockChallengeCoordinator.loadOrComputeBlockChallengeProof(ctx, req.Height) 176 176 + if err != nil { 177 177 + return nil, stacktrace.Propagate(err, "") 178 178 + } 179 179 + return &abcitypes.ResponseExtendVote{ 180 180 + VoteExtension: proof, 181 181 + }, nil 166 182 } 167 183 168 184 // VerifyVoteExtension implements [types.Application]. 169 169 - func (d *DIDPLCApplication) VerifyVoteExtension(context.Context, *abcitypes.RequestVerifyVoteExtension) (*abcitypes.ResponseVerifyVoteExtension, error) { 170 170 - // TODO 171 171 - return &abcitypes.ResponseVerifyVoteExtension{}, nil 185 185 + func (d *DIDPLCApplication) VerifyVoteExtension(_ context.Context, req *abcitypes.RequestVerifyVoteExtension) (*abcitypes.ResponseVerifyVoteExtension, error) { 186 186 + proofOK, err := d.blockChallengeCoordinator.verifyBlockChallengeProof(req.Height, req.ValidatorAddress, req.VoteExtension) 187 187 + if err != nil { 188 188 + return nil, stacktrace.Propagate(err, "") 189 189 + } 190 190 + 191 191 + return &abcitypes.ResponseVerifyVoteExtension{ 192 192 + Status: lo.Ternary(proofOK, abcitypes.ResponseVerifyVoteExtension_ACCEPT, abcitypes.ResponseVerifyVoteExtension_REJECT), 193 193 + }, nil 172 194 } 173 195 174 196 // FinalizeBlock implements [types.Application].

abciapp/proofcircuit/BlockChallengeCircuit_ConstraintSystem

This is a binary file and will not be displayed.

abciapp/proofcircuit/BlockChallengeCircuit_ProvingKey

This is a binary file and will not be displayed.

abciapp/proofcircuit/BlockChallengeCircuit_VerifyingKey

This is a binary file and will not be displayed.

abciapp/proofcircuit/BlockChallenge_ConstraintSystem

This is a binary file and will not be displayed.

abciapp/proofcircuit/BlockChallenge_ProvingKey

This is a binary file and will not be displayed.

abciapp/proofcircuit/BlockChallenge_VerifyingKey

This is a binary file and will not be displayed.

-4

dbmtoiavldb/adapter.go

··· 73 73 } 74 74 75 75 func (i *AdaptedIterator) Next() { 76 76 - /*if !i.calledNextOnce { 77 77 - i.calledNextOnce = true 78 78 - return 79 79 - }*/ 80 76 i.underlying.Next() 81 77 } 82 78

+15 -2

go.mod

··· 4 4 5 5 require ( 6 6 cosmossdk.io/core v0.12.1-0.20240725072823-6a2d039e1212 7 7 + github.com/Yiling-J/theine-go v0.6.2 7 8 github.com/bits-and-blooms/bloom/v3 v3.7.1 8 9 github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe 9 10 github.com/cometbft/cometbft v0.38.19 10 11 github.com/cometbft/cometbft-db v0.14.1 12 12 + github.com/consensys/gnark v0.14.0 13 13 + github.com/consensys/gnark-crypto v0.19.0 11 14 github.com/cosmos/iavl v1.3.5 12 15 github.com/cosmos/ics23/go v0.10.0 13 16 github.com/dgraph-io/badger/v4 v4.9.0 ··· 20 23 github.com/polydawn/refmt v0.89.1-0.20221221234430-40501e09de1f 21 24 github.com/puzpuzpuz/xsync/v4 v4.2.0 22 25 github.com/rs/cors v1.11.1 26 26 + github.com/rs/zerolog v1.34.0 23 27 github.com/samber/lo v1.52.0 24 28 github.com/samber/mo v1.16.0 25 29 github.com/spf13/viper v1.19.0 26 30 github.com/stretchr/testify v1.11.1 27 31 github.com/ucarion/urlpath v0.0.0-20200424170820-7ccc79b76bbb 32 32 + resenje.org/singleflight v0.4.3 28 33 ) 29 34 30 35 require ( 31 36 github.com/DataDog/zstd v1.4.5 // indirect 32 37 github.com/beorn7/perks v1.0.1 // indirect 33 38 github.com/bits-and-blooms/bitset v1.24.2 // indirect 39 39 + github.com/blang/semver/v4 v4.0.0 // indirect 34 40 github.com/cespare/xxhash/v2 v2.3.0 // indirect 35 41 github.com/cockroachdb/errors v1.11.3 // indirect 36 42 github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce // indirect ··· 45 51 github.com/dustin/go-humanize v1.0.1 // indirect 46 52 github.com/emicklei/dot v1.6.2 // indirect 47 53 github.com/fsnotify/fsnotify v1.7.0 // indirect 54 54 + github.com/fxamacker/cbor/v2 v2.9.0 // indirect 48 55 github.com/getsentry/sentry-go v0.27.0 // indirect 49 56 github.com/go-kit/kit v0.13.0 // indirect 50 57 github.com/go-kit/log v0.2.1 // indirect ··· 58 65 github.com/google/flatbuffers v25.2.10+incompatible // indirect 59 66 github.com/google/go-cmp v0.7.0 // indirect 60 67 github.com/google/orderedcode v0.0.1 // indirect 68 68 + github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6 // indirect 61 69 github.com/gorilla/websocket v1.5.3 // indirect 62 70 github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect 63 71 github.com/hashicorp/hcl v1.0.0 // indirect 72 72 + github.com/ingonyama-zk/icicle-gnark/v3 v3.2.2 // indirect 64 73 github.com/ipfs/go-block-format v0.2.0 // indirect 65 74 github.com/ipfs/go-ipfs-util v0.0.3 // indirect 66 75 github.com/ipfs/go-ipld-format v0.6.0 // indirect ··· 71 80 github.com/lib/pq v1.10.9 // indirect 72 81 github.com/linxGnu/grocksdb v1.8.14 // indirect 73 82 github.com/magiconair/properties v1.8.7 // indirect 83 83 + github.com/mattn/go-colorable v0.1.14 // indirect 84 84 + github.com/mattn/go-isatty v0.0.20 // indirect 74 85 github.com/minio/highwayhash v1.0.3 // indirect 75 86 github.com/minio/sha256-simd v1.0.1 // indirect 76 87 github.com/mitchellh/mapstructure v1.5.0 // indirect ··· 92 103 github.com/prometheus/procfs v0.15.1 // indirect 93 104 github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect 94 105 github.com/rogpeppe/go-internal v1.13.1 // indirect 106 106 + github.com/ronanh/intcomp v1.1.1 // indirect 95 107 github.com/sagikazarmark/locafero v0.4.0 // indirect 96 108 github.com/sagikazarmark/slog-shim v0.1.0 // indirect 97 109 github.com/sasha-s/go-deadlock v0.3.5 // indirect ··· 103 115 github.com/subosito/gotenv v1.6.0 // indirect 104 116 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect 105 117 github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e // indirect 118 118 + github.com/x448/float16 v0.8.4 // indirect 119 119 + github.com/zeebo/xxh3 v1.0.2 // indirect 106 120 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect 107 121 gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect 108 122 go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5 // indirect ··· 112 126 go.opentelemetry.io/otel/trace v1.37.0 // indirect 113 127 go.uber.org/multierr v1.11.0 // indirect 114 128 golang.org/x/crypto v0.41.0 // indirect 115 115 - golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect 129 129 + golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b // indirect 116 130 golang.org/x/net v0.43.0 // indirect 117 131 golang.org/x/sync v0.16.0 // indirect 118 132 golang.org/x/sys v0.36.0 // indirect 119 133 golang.org/x/text v0.28.0 // indirect 120 120 - golang.org/x/tools v0.36.0 // indirect 121 134 golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect 122 135 google.golang.org/genproto/googleapis/rpc v0.0.0-20241202173237-19429a94021a // indirect 123 136 google.golang.org/grpc v1.70.0 // indirect

+45 -2

go.sum

··· 11 11 github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= 12 12 github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE= 13 13 github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= 14 14 + github.com/Yiling-J/theine-go v0.6.2 h1:1GeoXeQ0O0AUkiwj2S9Jc0Mzx+hpqzmqsJ4kIC4M9AY= 15 15 + github.com/Yiling-J/theine-go v0.6.2/go.mod h1:08QpMa5JZ2pKN+UJCRrCasWYO1IKCdl54Xa836rpmDU= 14 16 github.com/adlio/schema v1.3.6 h1:k1/zc2jNfeiZBA5aFTRy37jlBIuCkXCm0XmvpzCKI9I= 15 17 github.com/adlio/schema v1.3.6/go.mod h1:qkxwLgPBd1FgLRHYVCmQT/rrBr3JH38J9LjmVzWNudg= 16 18 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= ··· 19 21 github.com/bits-and-blooms/bitset v1.24.2/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= 20 22 github.com/bits-and-blooms/bloom/v3 v3.7.1 h1:WXovk4TRKZttAMJfoQx6K2DM0zNIt8w+c67UqO+etV0= 21 23 github.com/bits-and-blooms/bloom/v3 v3.7.1/go.mod h1:rZzYLLje2dfzXfAkJNxQQHsKurAyK55KUnL43Euk0hU= 24 24 + github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= 25 25 + github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= 22 26 github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe h1:VBhaqE5ewQgXbY5SfSWFZC/AwHFo7cHxZKFYi2ce9Yo= 23 27 github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe/go.mod h1:RuQVrCGm42QNsgumKaR6se+XkFKfCPNwdCiTvqKRUck= 24 28 github.com/btcsuite/btcd/btcutil v1.1.6 h1:zFL2+c3Lb9gEgqKNzowKUPQNb8jV7v5Oaodi/AYFd6c= ··· 45 49 github.com/cometbft/cometbft v0.38.19/go.mod h1:UCu8dlHqvkAsmAFmWDRWNZJPlu6ya2fTWZlDrWsivwo= 46 50 github.com/cometbft/cometbft-db v0.14.1 h1:SxoamPghqICBAIcGpleHbmoPqy+crij/++eZz3DlerQ= 47 51 github.com/cometbft/cometbft-db v0.14.1/go.mod h1:KHP1YghilyGV/xjD5DP3+2hyigWx0WTp9X+0Gnx0RxQ= 52 52 + github.com/consensys/gnark v0.14.0 h1:RG+8WxRanFSFBSlmCDRJnYMYYKpH3Ncs5SMzg24B5HQ= 53 53 + github.com/consensys/gnark v0.14.0/go.mod h1:1IBpDPB/Rdyh55bQRR4b0z1WvfHQN1e0020jCvKP2Gk= 54 54 + github.com/consensys/gnark-crypto v0.19.0 h1:zXCqeY2txSaMl6G5wFpZzMWJU9HPNh8qxPnYJ1BL9vA= 55 55 + github.com/consensys/gnark-crypto v0.19.0/go.mod h1:rT23F0XSZqE0mUA0+pRtnL56IbPxs6gp4CeRsBk4XS0= 48 56 github.com/containerd/continuity v0.3.0 h1:nisirsYROK15TAMVukJOUyGJjz4BNQJBVsNvAXZJ/eg= 49 57 github.com/containerd/continuity v0.3.0/go.mod h1:wJEAIwKOm/pBZuBd0JmeTvnLquTB1Ag8espWhkykbPM= 58 58 + github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= 50 59 github.com/cosmos/gogoproto v1.7.0 h1:79USr0oyXAbxg3rspGh/m4SWNyoz/GLaAh0QlCe2fro= 51 60 github.com/cosmos/gogoproto v1.7.0/go.mod h1:yWChEv5IUEYURQasfyBW5ffkMHR/90hiHgbNgrtp4j0= 52 61 github.com/cosmos/iavl v1.3.5 h1:wTDFbaa/L0FVUrwTlzMnjN3fphtKgWxgcZmTc45MZuA= ··· 87 96 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= 88 97 github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= 89 98 github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= 99 99 + github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM= 100 100 + github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ= 90 101 github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= 91 102 github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= 92 103 github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= ··· 103 114 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= 104 115 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= 105 116 github.com/go-yaml/yaml v2.1.0+incompatible/go.mod h1:w2MrLa16VYP0jy6N7M5kHaCkaLENm+P+Tv+MfurjSw0= 117 117 + github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= 106 118 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= 107 119 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= 108 120 github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= ··· 129 141 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= 130 142 github.com/google/orderedcode v0.0.1 h1:UzfcAexk9Vhv8+9pNOgRu41f16lHq725vPwnSeiG/Us= 131 143 github.com/google/orderedcode v0.0.1/go.mod h1:iVyU4/qPKHY5h/wSd6rZZCDcLJNxiWO6dvsYES2Sb20= 144 144 + github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6 h1:EEHtgt9IwisQ2AZ4pIsMjahcegHh6rmhqxzIRQIyepY= 145 145 + github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6/go.mod h1:I6V7YzU0XDpsHqbsyrghnFZLO1gwK6NPTNvmetQIk9U= 132 146 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= 133 147 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= 134 148 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8= ··· 142 156 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= 143 157 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= 144 158 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= 159 159 + github.com/ingonyama-zk/icicle-gnark/v3 v3.2.2 h1:B+aWVgAx+GlFLhtYjIaF0uGjU3rzpl99Wf9wZWt+Mq8= 160 160 + github.com/ingonyama-zk/icicle-gnark/v3 v3.2.2/go.mod h1:CH/cwcr21pPWH+9GtK/PFaa4OGTv4CtfkCKro6GpbRE= 145 161 github.com/ipfs/go-block-format v0.2.0 h1:ZqrkxBA2ICbDRbK8KJs/u0O3dlp6gmAuuXUJNiW1Ycs= 146 162 github.com/ipfs/go-block-format v0.2.0/go.mod h1:+jpL11nFx5A/SPpsoBn6Bzkra/zaArfSmsknbPMYgzM= 147 163 github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= ··· 168 184 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= 169 185 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= 170 186 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= 187 187 + github.com/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4= 188 188 + github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c= 171 189 github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= 172 190 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= 173 191 github.com/linxGnu/grocksdb v1.8.14 h1:HTgyYalNwBSG/1qCQUIott44wU5b2Y9Kr3z7SK5OfGQ= 174 192 github.com/linxGnu/grocksdb v1.8.14/go.mod h1:QYiYypR2d4v63Wj1adOOfzglnoII0gLj3PNh4fZkcFA= 175 193 github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= 176 194 github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= 195 195 + github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= 196 196 + github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= 197 197 + github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= 198 198 + github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= 199 199 + github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= 200 200 + github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= 201 201 + github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= 177 202 github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD6Q= 178 203 github.com/minio/highwayhash v1.0.3/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ= 179 204 github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= ··· 243 268 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= 244 269 github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII= 245 270 github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o= 271 271 + github.com/ronanh/intcomp v1.1.1 h1:+1bGV/wEBiHI0FvzS7RHgzqOpfbBJzLIxkqMJ9e6yxY= 272 272 + github.com/ronanh/intcomp v1.1.1/go.mod h1:7FOLy3P3Zj3er/kVrU/pl+Ql7JFZj7bwliMGketo0IU= 246 273 github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA= 247 274 github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= 275 275 + github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= 276 276 + github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY= 277 277 + github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ= 248 278 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= 249 279 github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= 250 280 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= ··· 300 330 github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw= 301 331 github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e h1:28X54ciEwwUxyHn9yrZfl5ojgF4CBNLWX7LR0rvBkf4= 302 332 github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so= 333 333 + github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= 334 334 + github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= 303 335 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= 304 336 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= 337 337 + github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ= 338 338 + github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= 339 339 + github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0= 340 340 + github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= 305 341 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b h1:CzigHMRySiX3drau9C6Q5CAbNIApmLdat5jPMqChvDA= 306 342 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b/go.mod h1:/y/V339mxv2sZmYYR64O07VuCpdNZqCTwO8ZcouTMI8= 307 343 gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 h1:qwDnMxjkyLmAFgcfgTnfJrmYKWhHnci3GjDqcZp1M3Q= ··· 327 363 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= 328 364 golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= 329 365 golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= 330 330 - golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o= 331 331 - golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8= 366 366 + golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b h1:DXr+pvt3nC887026GRP39Ej11UATqWDmWuS99x26cD0= 367 367 + golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b/go.mod h1:4QTo5u+SEIbbKW1RacMZq1YEfOBqeXa19JeshGi+zc4= 332 368 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= 333 369 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= 334 370 golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= ··· 359 395 golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 360 396 golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 361 397 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 398 398 + golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 362 399 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 400 400 + golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 401 401 + golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 363 402 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= 364 403 golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k= 365 404 golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= ··· 404 443 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= 405 444 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= 406 445 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= 446 446 + gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= 447 447 + gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= 407 448 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 408 449 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 409 450 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 410 451 lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI= 411 452 lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k= 453 453 + resenje.org/singleflight v0.4.3 h1:l7foFYg8X/VEHPxWs1K/Pw77807RMVzvXgWGb0J1sdM= 454 454 + resenje.org/singleflight v0.4.3/go.mod h1:lAgQK7VfjG6/pgredbQfmV0RvG/uVhKo6vSuZ0vCWfk=

+11 -6

main.go

··· 90 90 os.Remove(didBloomFilterPath) 91 91 } 92 92 93 93 - app, txFactory, plc, cleanup, err := abciapp.NewDIDPLCApplication(treeDB, indexDB, recreateDatabases, filepath.Join(homeDir, "snapshots"), didBloomFilterPath) 94 94 - if err != nil { 95 95 - log.Fatalf("failed to create DIDPLC application: %v", err) 96 96 - } 97 97 - defer cleanup() 98 98 - 99 93 pv := privval.LoadFilePV( 100 94 config.PrivValidatorKeyFile(), 101 95 config.PrivValidatorStateFile(), 102 96 ) 97 97 + 98 98 + app, txFactory, plc, cleanup, err := abciapp.NewDIDPLCApplication(pv, treeDB, indexDB, recreateDatabases, filepath.Join(homeDir, "snapshots"), didBloomFilterPath) 99 99 + if err != nil { 100 100 + log.Fatalf("failed to create DIDPLC application: %v", err) 101 101 + } 102 102 + defer cleanup() 103 103 104 104 nodeKey, err := p2p.LoadNodeKey(config.NodeKeyFile()) 105 105 if err != nil { ··· 126 126 127 127 if err != nil { 128 128 log.Fatalf("Creating node: %v", err) 129 129 + } 130 130 + 131 131 + err = app.FinishInitializing(node.BlockStore()) 132 132 + if err != nil { 133 133 + log.Fatalf("Finishing ABCI app initialization: %v", err) 129 134 } 130 135 131 136 err = node.Start()

+3

plc/plc_test.go

··· 204 204 205 205 require.Equal(t, "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q", export[0].Operation.AsOperation().CID().String()) 206 206 require.Equal(t, "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q", export[0].CID.String()) 207 207 + require.Equal(t, uint64(1), export[0].Seq) 207 208 require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[1].Operation.AsOperation().CID().String()) 208 209 require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[1].CID.String()) 210 210 + require.Equal(t, uint64(2), export[1].Seq) 209 211 require.Equal(t, "bafyreigyzl2esgnk7nvav5myvgywbshdmatzthc73iiar7tyeq3xjt47m4", export[2].Operation.AsOperation().CID().String()) 210 212 require.Equal(t, "bafyreigyzl2esgnk7nvav5myvgywbshdmatzthc73iiar7tyeq3xjt47m4", export[2].CID.String()) 213 213 + require.Equal(t, uint64(3), export[2].Seq) 211 214 212 215 // the after parameter is exclusive, with a limit of 1, we should just get the second successful operation 213 216 export, err = testPLC.Export(ctx, txFactory.ReadCommitted(), export[0].Seq, 1)

+41

proof/block_challenge.go

··· 1 1 + package proof 2 2 + 3 3 + import ( 4 4 + "github.com/consensys/gnark/frontend" 5 5 + "github.com/consensys/gnark/std/hash/mimc" 6 6 + ) 7 7 + 8 8 + const OperationDataVariables = 50 9 9 + const OperationDataLength = OperationDataVariables * 31 10 10 + 11 11 + type BlockChallengeCircuit struct { 12 12 + OperationData [OperationDataVariables]frontend.Variable 13 13 + LastCommitHash frontend.Variable `gnark:",public"` // A unique challenge ID, the same for all validators 14 14 + SharedHash frontend.Variable `gnark:",public"` // Hash(LastCommitHash, OperationData) 15 15 + 16 16 + // Validator-specific: 17 17 + ValidatorAddress frontend.Variable `gnark:",public"` 18 18 + SpecificHash frontend.Variable `gnark:",public"` // Hash(ValidatorID, SharedHash) 19 19 + } 20 20 + 21 21 + func (circuit *BlockChallengeCircuit) Define(api frontend.API) error { 22 22 + mimc, _ := mimc.NewMiMC(api) 23 23 + 24 24 + mimc.Write(circuit.LastCommitHash) 25 25 + 26 26 + for i := 0; i < len(circuit.OperationData); i++ { 27 27 + mimc.Write(circuit.OperationData[i]) 28 28 + } 29 29 + 30 30 + computedSharedHash := mimc.Sum() 31 31 + api.AssertIsEqual(circuit.SharedHash, computedSharedHash) 32 32 + 33 33 + mimc.Reset() 34 34 + 35 35 + mimc.Write(circuit.ValidatorAddress) 36 36 + mimc.Write(computedSharedHash) 37 37 + 38 38 + api.AssertIsEqual(circuit.SpecificHash, mimc.Sum()) 39 39 + 40 40 + return nil 41 41 + }

+96

proof/block_challenge_test.go

··· 1 1 + package proof 2 2 + 3 3 + import ( 4 4 + "encoding/hex" 5 5 + "slices" 6 6 + "testing" 7 7 + "time" 8 8 + 9 9 + "github.com/consensys/gnark-crypto/ecc" 10 10 + "github.com/consensys/gnark-crypto/ecc/bn254" 11 11 + "github.com/consensys/gnark/backend/groth16" 12 12 + "github.com/consensys/gnark/frontend" 13 13 + "github.com/consensys/gnark/frontend/cs/r1cs" 14 14 + "github.com/samber/lo" 15 15 + "github.com/stretchr/testify/require" 16 16 + 17 17 + "github.com/consensys/gnark-crypto/ecc/bn254/fr/mimc" 18 18 + ) 19 19 + 20 20 + func TestBlockChallenge(t *testing.T) { 21 21 + st := time.Now() 22 22 + 23 23 + var bcCircuit BlockChallengeCircuit 24 24 + r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs.NewBuilder, &bcCircuit) 25 25 + require.NoError(t, err) 26 26 + 27 27 + t.Log("Compile took", time.Since(st)) 28 28 + 29 29 + st = time.Now() 30 30 + pk, vk, err := groth16.Setup(r1cs) 31 31 + require.NoError(t, err) 32 32 + t.Log("Setup took", time.Since(st)) 33 33 + 34 34 + st = time.Now() 35 35 + origValidatorID := lo.Must(hex.DecodeString("deadbeefdeadbeefdeadbeefdeadbeef")) 36 36 + origLastCommitHash := lo.Must(hex.DecodeString("deadf00ddeadf00ddeadf00ddeadbeef")) 37 37 + 38 38 + opDataSlice := slices.Repeat(lo.Must(hex.DecodeString("ffee")), 775) 39 39 + opData := [1550]byte{} 40 40 + copy(opData[:], opDataSlice) 41 41 + assignmentShared, sharedHash := buildBlockChallengeCircuitAssignmentShared(origLastCommitHash, opData) 42 42 + assignment := buildBlockChallengeCircuitAssignmentFull(assignmentShared, sharedHash, origValidatorID) 43 43 + t.Log("Out of circuit took", time.Since(st)) 44 44 + 45 45 + st = time.Now() 46 46 + witness, err := frontend.NewWitness(assignment, bn254.ID.ScalarField()) 47 47 + require.NoError(t, err) 48 48 + t.Log("Witness took", time.Since(st)) 49 49 + 50 50 + st = time.Now() 51 51 + proof, err := groth16.Prove(r1cs, pk, witness) 52 52 + require.NoError(t, err) 53 53 + t.Log("Prove took", time.Since(st)) 54 54 + 55 55 + publicWitness, err := witness.Public() 56 56 + require.NoError(t, err) 57 57 + 58 58 + st = time.Now() 59 59 + err = groth16.Verify(proof, vk, publicWitness) 60 60 + require.NoError(t, err) 61 61 + t.Log("Verify took", time.Since(st)) 62 62 + } 63 63 + 64 64 + func buildBlockChallengeCircuitAssignmentShared(lastCommitHash []byte, data [1550]byte) (BlockChallengeCircuit, []byte) { 65 65 + var assignment BlockChallengeCircuit 66 66 + 67 67 + h := mimc.NewMiMC() 68 68 + 69 69 + if len(lastCommitHash) > 31 { 70 70 + lastCommitHash = lastCommitHash[len(lastCommitHash)-31:] 71 71 + } 72 72 + h.Write(lastCommitHash) 73 73 + assignment.LastCommitHash = lastCommitHash 74 74 + 75 75 + for i := 0; i < len(assignment.OperationData); i++ { 76 76 + d := data[31*i : 31*(i+1)] 77 77 + assignment.OperationData[i] = d 78 78 + h.Write(d) 79 79 + } 80 80 + 81 81 + sharedHash := h.Sum(nil) 82 82 + assignment.SharedHash = sharedHash 83 83 + return assignment, sharedHash 84 84 + } 85 85 + 86 86 + func buildBlockChallengeCircuitAssignmentFull(shared BlockChallengeCircuit, sharedHash, validatorAddress []byte) *BlockChallengeCircuit { 87 87 + h := mimc.NewMiMC() 88 88 + 89 89 + h.Write(validatorAddress) 90 90 + h.Write(sharedHash) 91 91 + 92 92 + shared.ValidatorAddress = validatorAddress 93 93 + shared.SpecificHash = h.Sum(nil) 94 94 + 95 95 + return &shared 96 96 + }

+62

proof/writer/writer.go

··· 1 1 + package main 2 2 + 3 3 + import ( 4 4 + "io" 5 5 + "log" 6 6 + "os" 7 7 + 8 8 + "github.com/consensys/gnark-crypto/ecc" 9 9 + "github.com/consensys/gnark/backend/groth16" 10 10 + "github.com/consensys/gnark/frontend" 11 11 + "github.com/consensys/gnark/frontend/cs/r1cs" 12 12 + "github.com/palantir/stacktrace" 13 13 + "tangled.org/gbl08ma.com/didplcbft/proof" 14 14 + ) 15 15 + 16 16 + func main() { 17 17 + var bcCircuit proof.BlockChallengeCircuit 18 18 + r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs.NewBuilder, &bcCircuit) 19 19 + if err != nil { 20 20 + log.Fatalln(stacktrace.Propagate(err, "failed to compile circuit")) 21 21 + } 22 22 + 23 23 + pk, vk, err := groth16.Setup(r1cs) 24 24 + if err != nil { 25 25 + log.Fatalln(stacktrace.Propagate(err, "failed setup")) 26 26 + } 27 27 + 28 28 + toWrite := []struct { 29 29 + writerTo io.WriterTo 30 30 + fileName string 31 31 + }{ 32 32 + { 33 33 + writerTo: r1cs, 34 34 + fileName: "../../abciapp/proofcircuit/BlockChallenge_ConstraintSystem", 35 35 + }, 36 36 + { 37 37 + writerTo: pk, 38 38 + fileName: "../../abciapp/proofcircuit/BlockChallenge_ProvingKey", 39 39 + }, 40 40 + { 41 41 + writerTo: vk, 42 42 + fileName: "../../abciapp/proofcircuit/BlockChallenge_VerifyingKey", 43 43 + }, 44 44 + } 45 45 + 46 46 + for _, entry := range toWrite { 47 47 + func() { 48 48 + file, err := os.OpenFile(entry.fileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644) 49 49 + if err != nil { 50 50 + log.Fatalln(stacktrace.Propagate(err, "failed to open file %s for writing", entry.fileName)) 51 51 + } 52 52 + defer file.Close() 53 53 + 54 54 + _, err = entry.writerTo.WriteTo(file) 55 55 + if err != nil { 56 56 + log.Fatalln(stacktrace.Propagate(err, "failed write to file %s", entry.fileName)) 57 57 + } 58 58 + }() 59 59 + } 60 60 + 61 61 + log.Println("Done") 62 62 + }

+74 -14

store/consensus.go

··· 32 32 AuditLogReverseIterator(ctx context.Context, tx transaction.Read, did string, err *error) iter.Seq[types.SequencedLogEntry] 33 33 34 34 ExportOperations(ctx context.Context, tx transaction.Read, after uint64, count int) ([]types.SequencedLogEntry, error) // passing a count of zero means unlimited 35 35 - OperationsIterator(tx transaction.Read, after uint64, retErr *error) iter.Seq[types.SequencedLogEntry] 35 35 + OperationsIterator(tx transaction.Read, after uint64, retErr *error) iter.Seq2[types.SequencedLogEntry, []byte] 36 36 37 37 StoreOperation(ctx context.Context, tx transaction.Write, entry didplc.LogEntry, nullifyWithSequenceEqualOrGreaterThan mo.Option[uint64]) error 38 38 SetOperationCreatedAt(tx transaction.Write, seqID uint64, createdAt time.Time) error 39 39 40 40 - NextOperationSequence(tx transaction.Read) (uint64, error) 40 40 + CountOperations(tx transaction.Read) (uint64, error) 41 41 42 42 AuthoritativePLC(tx transaction.Read) (string, error) 43 43 SetAuthoritativePLC(tx transaction.Write, url string) error 44 44 45 45 AuthoritativeImportProgress(tx transaction.Read) (uint64, error) 46 46 SetAuthoritativeImportProgress(tx transaction.Write, nextCursor uint64) error 47 47 + 48 48 + BlockChallengeProof(tx transaction.Read, height uint64) ([]byte, error) 49 49 + BlockChalengeProofsIterator(tx transaction.Read, afterHeight uint64, retErr *error) iter.Seq2[uint64, []byte] // afterHeight is exclusive for consistency with OperationsIterator 50 50 + StoreBlockChallengeProof(ctx context.Context, tx transaction.WriteIndex, blockHeight uint64, proof []byte) error 47 51 } 48 52 49 53 var _ ConsensusStore = (*consensusStore)(nil) ··· 123 127 124 128 func (t *consensusStore) AuditLogReverseIterator(ctx context.Context, tx transaction.Read, did string, retErr *error) iter.Seq[types.SequencedLogEntry] { 125 129 return func(yield func(types.SequencedLogEntry) bool) { 130 130 + *retErr = nil 131 131 + 126 132 didBytes, err := DIDToBytes(did) 127 133 if err != nil { 128 134 *retErr = stacktrace.Propagate(err, "") ··· 195 201 func (t *consensusStore) ExportOperations(ctx context.Context, tx transaction.Read, after uint64, count int) ([]types.SequencedLogEntry, error) { 196 202 entries := make([]types.SequencedLogEntry, 0, count) 197 203 var iterErr error 198 198 - for logEntry := range t.OperationsIterator(tx, after, &iterErr) { 204 204 + for logEntry, _ := range t.OperationsIterator(tx, after, &iterErr) { 199 205 entries = append(entries, logEntry) 200 206 201 207 // this condition being checked here also makes it so that a count of zero means unlimited ··· 209 215 return entries, nil 210 216 } 211 217 212 212 - func (t *consensusStore) OperationsIterator(tx transaction.Read, after uint64, retErr *error) iter.Seq[types.SequencedLogEntry] { 213 213 - return func(yield func(types.SequencedLogEntry) bool) { 218 218 + func (t *consensusStore) OperationsIterator(tx transaction.Read, after uint64, retErr *error) iter.Seq2[types.SequencedLogEntry, []byte] { 219 219 + return func(yield func(types.SequencedLogEntry, []byte) bool) { 220 220 + *retErr = nil 221 221 + 214 222 // as the name suggests, after is an exclusive lower bound, but our iterators use inclusive lower bounds 215 223 start := after + 1 216 224 startKey := marshalOperationKey(start) ··· 231 239 return 232 240 } 233 241 234 234 - if !yield(logEntry) { 242 242 + if !yield(logEntry, opIterator.Value()) { 235 243 return 236 244 } 237 245 ··· 246 254 247 255 // StoreOperation stores an operation in the tree, nullifying existing operations whose index within the DID's history 248 256 // is lower or equal to the specified optional integer. 249 249 - // 250 250 - // Even though this function is not meant to overwrite operations (it will error) we ask the caller to provide the sequence 251 251 - // The caller is responsible for managing the sequence and invalidating it when needed (e.g. after a rollback) using 252 252 - // [[consensusStore.NextOperationSequence]]. 253 253 - // Pushing the responsibility to the caller is preferable in terms of performance, even if it leads to less safe code, 254 254 - // because getting the sequence from the tree within this function every time has a significant performance hit 255 257 func (t *consensusStore) StoreOperation(ctx context.Context, tx transaction.Write, entry didplc.LogEntry, nullifyWithSequenceEqualOrGreaterThan mo.Option[uint64]) error { 256 258 didBytes, err := DIDToBytes(entry.DID) 257 259 if err != nil { ··· 382 384 var minOperationKey = marshalOperationKey(0) 383 385 var maxOperationKey = marshalOperationKey(math.MaxInt64) 384 386 385 385 - func (t *consensusStore) NextOperationSequence(tx transaction.Read) (uint64, error) { 387 387 + func (t *consensusStore) CountOperations(tx transaction.Read) (uint64, error) { 386 388 seq := uint64(0) 387 389 388 390 itr, err := tx.Tree().Iterator(minOperationKey, maxOperationKey, false) ··· 398 400 return 0, stacktrace.Propagate(err, "") 399 401 } 400 402 } 401 401 - return seq + 1, stacktrace.Propagate(err, "") 403 403 + return seq, stacktrace.Propagate(err, "") 402 404 } 403 405 404 406 func DIDToBytes(did string) ([]byte, error) { ··· 619 621 _, err := tx.Tree().Set([]byte("aImportProgress"), value) 620 622 return stacktrace.Propagate(err, "") 621 623 } 624 624 + 625 625 + func marshalBlockChallengeProofKey(block uint64) []byte { 626 626 + key := make([]byte, 1+8) 627 627 + key[0] = 'c' 628 628 + 629 629 + binary.BigEndian.PutUint64(key[1:], block) 630 630 + 631 631 + return key 632 632 + } 633 633 + 634 634 + func unmarshalBlockChallengeProofKey(key []byte) uint64 { 635 635 + return binary.BigEndian.Uint64(key[1:9]) 636 636 + } 637 637 + 638 638 + var maxBlockChallengeProofKey = marshalBlockChallengeProofKey(math.MaxInt64) 639 639 + 640 640 + func (t *consensusStore) BlockChallengeProof(tx transaction.Read, height uint64) ([]byte, error) { 641 641 + key := marshalBlockChallengeProofKey(height) 642 642 + value, err := tx.IndexDB().Get(key) 643 643 + return value, stacktrace.Propagate(err, "") 644 644 + } 645 645 + 646 646 + func (t *consensusStore) BlockChalengeProofsIterator(tx transaction.Read, afterHeight uint64, retErr *error) iter.Seq2[uint64, []byte] { 647 647 + return func(yield func(uint64, []byte) bool) { 648 648 + *retErr = nil 649 649 + // as the name suggests, after is an exclusive lower bound, but our iterators use inclusive lower bounds 650 650 + start := afterHeight + 1 651 651 + startKey := marshalBlockChallengeProofKey(start) 652 652 + endKey := maxBlockChallengeProofKey 653 653 + 654 654 + proofsIterator, err := tx.IndexDB().Iterator(startKey, endKey) 655 655 + if err != nil { 656 656 + *retErr = stacktrace.Propagate(err, "") 657 657 + return 658 658 + } 659 659 + 660 660 + defer proofsIterator.Close() 661 661 + 662 662 + for proofsIterator.Valid() { 663 663 + blockHeight := unmarshalBlockChallengeProofKey(proofsIterator.Key()) 664 664 + 665 665 + if !yield(blockHeight, proofsIterator.Value()) { 666 666 + return 667 667 + } 668 668 + 669 669 + proofsIterator.Next() 670 670 + } 671 671 + err = proofsIterator.Error() 672 672 + if err != nil { 673 673 + *retErr = stacktrace.Propagate(err, "") 674 674 + } 675 675 + } 676 676 + } 677 677 + 678 678 + func (t *consensusStore) StoreBlockChallengeProof(ctx context.Context, tx transaction.WriteIndex, blockHeight uint64, proof []byte) error { 679 679 + err := tx.IndexDB().Set(marshalBlockChallengeProofKey(blockHeight), proof) 680 680 + return stacktrace.Propagate(err, "") 681 681 + }

+1 -1

testutil/testutil.go

··· 23 23 _, indexDB, err := badgertodbm.NewBadgerInMemoryDB() 24 24 require.NoError(t, err) 25 25 26 26 - factory, err := transaction.NewFactory(tree, indexDB, store.Consensus.NextOperationSequence, store.NewInMemoryDIDBloomFilterStore()) 26 26 + factory, err := transaction.NewFactory(tree, indexDB, store.Consensus.CountOperations, store.NewInMemoryDIDBloomFilterStore()) 27 27 require.NoError(t, err) 28 28 29 29 return factory, tree, indexDB

+38 -23

transaction/factory.go

··· 28 28 type Factory struct { 29 29 bloomFilterStorage BloomFilterStorage 30 30 31 31 - db ExtendedDB 32 32 - mutableTree *iavl.MutableTree 33 33 - sequenceGetter func(tx Read) (uint64, error) 31 31 + db ExtendedDB 32 32 + mutableTreeMu sync.Mutex 33 33 + mutableTree *iavl.MutableTree 34 34 + operationCounter func(tx Read) (uint64, error) 34 35 35 36 bloomMu sync.RWMutex 36 37 bloomSeq uint64 ··· 40 41 bloomLastSaveSeq uint64 41 42 } 42 43 43 43 - func NewFactory(tree *iavl.MutableTree, indexDB ExtendedDB, sequenceGetter func(tx Read) (uint64, error), bloomFilterStorage BloomFilterStorage) (*Factory, error) { 44 44 + func NewFactory(tree *iavl.MutableTree, indexDB ExtendedDB, operationCounter func(tx Read) (uint64, error), bloomFilterStorage BloomFilterStorage) (*Factory, error) { 44 45 f := &Factory{ 45 46 bloomFilterStorage: bloomFilterStorage, 46 47 db: indexDB, 47 48 mutableTree: tree, 48 48 - sequenceGetter: sequenceGetter, 49 49 + operationCounter: operationCounter, 49 50 } 50 51 51 52 var err error ··· 57 58 if err != nil { 58 59 return nil, stacktrace.Propagate(err, "") 59 60 } 60 60 - f.bloomSeq, err = f.sequenceGetter(tx) 61 61 + f.bloomSeq, err = f.operationCounter(tx) 61 62 // since the sequenceGetter always returns the next sequence 62 63 f.bloomSeq-- 63 64 return f, stacktrace.Propagate(err, "") 64 65 } 65 66 66 67 func (f *Factory) ReadWorking(ts time.Time) Read { 68 68 + f.mutableTreeMu.Lock() 69 69 + defer f.mutableTreeMu.Unlock() 70 70 + 67 71 return &readTx{ 68 68 - ts: ts, 69 69 - height: f.mutableTree.WorkingVersion(), 70 70 - mutableTree: f.mutableTree, 71 71 - db: f.db, 72 72 - sequenceGetter: f.sequenceGetter, 73 73 - bloomMu: &f.bloomMu, 74 74 - bloomFilter: f.bloomFilter, 75 75 - bloomSeq: &f.bloomSeq, 72 72 + ts: ts, 73 73 + height: f.mutableTree.WorkingVersion(), 74 74 + mutableTree: f.mutableTree, 75 75 + db: f.db, 76 76 + operationCounter: f.operationCounter, 77 77 + bloomMu: &f.bloomMu, 78 78 + bloomFilter: f.bloomFilter, 79 79 + bloomSeq: &f.bloomSeq, 76 80 } 77 81 } 78 82 79 83 func (f *Factory) ReadCommitted() Read { 80 80 - tx, err := f.ReadHeight(time.Now(), f.mutableTree.Version()) 84 84 + f.mutableTreeMu.Lock() 85 85 + defer f.mutableTreeMu.Unlock() 86 86 + 87 87 + tx, err := f.readHeightWithinMu(time.Now(), f.mutableTree.Version()) 81 88 if err != nil { 82 89 // this should never happen, it's not worth making the signature of this function more 83 90 // complex for an error we'll never return unless the ABCI application is yet to be initialized ··· 86 93 return tx 87 94 } 88 95 89 89 - func (f *Factory) ReadHeight(ts time.Time, height int64) (Read, error) { 96 96 + func (f *Factory) readHeightWithinMu(ts time.Time, height int64) (Read, error) { 90 97 immutable, err := f.mutableTree.GetImmutable(height) 91 98 if err != nil { 92 99 if !errors.Is(err, iavl.ErrVersionDoesNotExist) || height != 0 { ··· 104 111 } 105 112 } 106 113 return &readTx{ 107 107 - ts: ts, 108 108 - height: height, 109 109 - tree: AdaptImmutableTree(immutable), 110 110 - db: f.db, 111 111 - sequenceGetter: f.sequenceGetter, 112 112 - bloomMu: &f.bloomMu, 113 113 - bloomFilter: f.bloomFilter, 114 114 + ts: ts, 115 115 + height: height, 116 116 + tree: AdaptImmutableTree(immutable), 117 117 + db: f.db, 118 118 + operationCounter: f.operationCounter, 119 119 + bloomMu: &f.bloomMu, 120 120 + bloomFilter: f.bloomFilter, 114 121 }, nil 122 122 + } 123 123 + 124 124 + func (f *Factory) ReadHeight(ts time.Time, height int64) (Read, error) { 125 125 + f.mutableTreeMu.Lock() 126 126 + defer f.mutableTreeMu.Unlock() 127 127 + 128 128 + tx, err := f.readHeightWithinMu(ts, height) 129 129 + return tx, stacktrace.Propagate(err, "") 115 130 } 116 131 117 132 func (f *Factory) SaveDIDBloomFilter() error {

+14 -5

transaction/interface.go

··· 11 11 Height() int64 12 12 Timestamp() time.Time 13 13 14 14 + CountOperations() (uint64, error) 14 15 Tree() ReadTree 15 15 - IndexDB() ReadIndex 16 16 + IndexDB() IndexReader 16 17 TestDIDBloomFilter(did []byte) bool 17 18 18 19 Upgrade() (Write, error) 20 20 + UpgradeForIndexOnly() (WriteIndex, error) 19 21 } 20 22 21 23 type Write interface { ··· 24 26 25 27 NextSequence() (uint64, error) 26 28 Tree() UnifiedTree 27 27 - IndexDB() WriteIndex 29 29 + IndexDB() IndexWriter 28 30 TestDIDBloomFilter(did []byte) bool 29 31 // sequence is only used to track how up-to-date the bloom filter is. it is not added to the bloom filter 30 32 AddToDIDBloomFilter(did []byte, sequence uint64) ··· 35 37 Downgrade() Read 36 38 } 37 39 38 38 - type ReadIndex interface { 40 40 + type WriteIndex interface { 41 41 + IndexDB() IndexWriter 42 42 + 43 43 + Commit() error 44 44 + Rollback() error 45 45 + } 46 46 + 47 47 + type IndexReader interface { 39 48 Get([]byte) ([]byte, error) 40 49 Has(key []byte) (bool, error) 41 50 ··· 44 53 ReverseIterator(start, end []byte) (dbm.Iterator, error) 45 54 } 46 55 47 47 - type WriteIndex interface { 48 48 - ReadIndex 56 56 + type IndexWriter interface { 57 57 + IndexReader 49 58 50 59 Delete([]byte) error 51 60 Set([]byte, []byte) error

+23 -1

transaction/read_on_write_tx.go

··· 2 2 3 3 import ( 4 4 "time" 5 5 + 6 6 + "github.com/palantir/stacktrace" 5 7 ) 6 8 7 9 // readOnWriteTx is created from a write tx to allow a write tx to be passed to functions that accept a read-only transaction ··· 16 18 } 17 19 18 20 // IndexDB implements [Read]. 19 19 - func (d *readOnWriteTx) IndexDB() ReadIndex { 21 21 + func (d *readOnWriteTx) IndexDB() IndexReader { 20 22 // by returning the write index we get the read uncommitted behavior we want 21 23 d.w.createWriteIndexIfNeeded() 22 24 return d.w.writeIndex ··· 27 29 return d.w.readTx.ts 28 30 } 29 31 32 32 + // CountOperations implements [Read]. 33 33 + func (d *readOnWriteTx) CountOperations() (uint64, error) { 34 34 + if d.w.hasSeq { 35 35 + return d.w.seq - 1, nil 36 36 + } 37 37 + count, err := d.w.readTx.CountOperations() 38 38 + if err != nil { 39 39 + return 0, stacktrace.Propagate(err, "") 40 40 + } 41 41 + // since we did the work, might as well set it on the writeTx too 42 42 + d.w.seq = count 43 43 + d.w.hasSeq = true 44 44 + return count, stacktrace.Propagate(err, "") 45 45 + } 46 46 + 30 47 // Tree implements [Read]. 31 48 func (d *readOnWriteTx) Tree() ReadTree { 32 49 // we can return the mutable tree as-is because it already presents read unsaved behavior ··· 42 59 func (d *readOnWriteTx) Upgrade() (Write, error) { 43 60 return d.w, nil 44 61 } 62 62 + 63 63 + // UpgradeForIndexOnly implements [Read]. 64 64 + func (d *readOnWriteTx) UpgradeForIndexOnly() (WriteIndex, error) { 65 65 + return d.w, nil 66 66 + }

+15 -2

transaction/read_tx.go

··· 21 21 bloomFilter *bloom.BloomFilter 22 22 bloomSeq *uint64 23 23 24 24 - sequenceGetter func(tx Read) (uint64, error) 24 24 + operationCounter func(tx Read) (uint64, error) 25 25 } 26 26 27 27 // Height implements [Read]. ··· 34 34 return t.ts 35 35 } 36 36 37 37 + // CountOperations implements [Read]. 38 38 + func (t *readTx) CountOperations() (uint64, error) { 39 39 + count, err := t.operationCounter(t) 40 40 + return count, stacktrace.Propagate(err, "") 41 41 + } 42 42 + 37 43 // Tree implements [Read]. 38 44 func (t *readTx) Tree() ReadTree { 39 45 if t.mutableTree != nil { ··· 43 49 } 44 50 45 51 // IndexDB implements [Read]. 46 46 - func (t *readTx) IndexDB() ReadIndex { 52 52 + func (t *readTx) IndexDB() IndexReader { 47 53 return t.db 48 54 } 49 55 ··· 64 70 unsavedBloomAdditions: map[string]struct{}{}, 65 71 }, nil 66 72 } 73 73 + 74 74 + // UpgradeForIndexOnly implements [Read]. 75 75 + func (t *readTx) UpgradeForIndexOnly() (WriteIndex, error) { 76 76 + return &writeIndexTx{ 77 77 + db: t.db, 78 78 + }, nil 79 79 + }

+14 -14

transaction/write_index.go

··· 21 21 unsavedRemovals map[string]struct{} 22 22 } 23 23 24 24 - // Delete implements [WriteIndex]. 24 24 + // Delete implements [IndexWriter]. 25 25 func (w *writeIndex) Delete(key []byte) error { 26 26 err := w.batch.Delete(key) 27 27 if err != nil { ··· 35 35 return nil 36 36 } 37 37 38 38 - // Set implements [WriteIndex]. 38 38 + // Set implements [IndexWriter]. 39 39 func (w *writeIndex) Set(key []byte, value []byte) error { 40 40 err := w.batch.Set(key, value) 41 41 if err != nil { ··· 49 49 return nil 50 50 } 51 51 52 52 - // Get implements [WriteIndex]. 52 52 + // Get implements [IndexWriter]. 53 53 func (w *writeIndex) Get(key []byte) ([]byte, error) { 54 54 kstr := unsafeBytesToStr(key) 55 55 ··· 64 64 return v, stacktrace.Propagate(err, "") 65 65 } 66 66 67 67 - // Has implements [WriteIndex]. 67 67 + // Has implements [IndexWriter]. 68 68 func (w *writeIndex) Has(key []byte) (bool, error) { 69 69 kstr := unsafeBytesToStr(key) 70 70 ··· 79 79 return v, stacktrace.Propagate(err, "") 80 80 } 81 81 82 82 - // IteratorWithOptions implements [WriteIndex]. 82 82 + // IteratorWithOptions implements [IndexWriter]. 83 83 func (w *writeIndex) IteratorWithOptions(start []byte, end []byte, opts badger.IteratorOptions) (dbm.Iterator, error) { 84 84 v, err := newUnsavedIterator(start, end, !opts.Reverse, w.db, w.unsavedAdditions, w.unsavedRemovals, &opts) 85 85 return v, stacktrace.Propagate(err, "") 86 86 } 87 87 88 88 - // Iterator implements [WriteIndex]. 88 88 + // Iterator implements [IndexWriter]. 89 89 func (w *writeIndex) Iterator(start []byte, end []byte) (dbm.Iterator, error) { 90 90 v, err := newUnsavedIterator(start, end, true, w.db, w.unsavedAdditions, w.unsavedRemovals, nil) 91 91 return v, stacktrace.Propagate(err, "") 92 92 } 93 93 94 94 - // ReverseIterator implements [WriteIndex]. 94 94 + // ReverseIterator implements [IndexWriter]. 95 95 func (w *writeIndex) ReverseIterator(start []byte, end []byte) (dbm.Iterator, error) { 96 96 v, err := newUnsavedIterator(start, end, false, w.db, w.unsavedAdditions, w.unsavedRemovals, nil) 97 97 return v, stacktrace.Propagate(err, "") ··· 189 189 return iter, nil 190 190 } 191 191 192 192 - // Domain implements [[dbm.Iterator]]. 192 192 + // Domain implements [dbm.Iterator]. 193 193 func (iter *unsavedIterator) Domain() ([]byte, []byte) { 194 194 return iter.start, iter.end 195 195 } 196 196 197 197 - // Valid implements [[dbm.Iterator]]. 197 197 + // Valid implements [dbm.Iterator]. 198 198 func (iter *unsavedIterator) Valid() bool { 199 199 if iter.start != nil && iter.end != nil { 200 200 if bytes.Compare(iter.end, iter.start) != 1 { ··· 205 205 return iter.underlyingIterator.Valid() || iter.nextUnsavedNodeIdx < len(iter.unsavedKeysToSort) || (iter.nextKey != nil && iter.nextVal != nil) 206 206 } 207 207 208 208 - // Key implements [[dbm.Iterator]] 208 208 + // Key implements [dbm.Iterator] 209 209 func (iter *unsavedIterator) Key() []byte { 210 210 return iter.nextKey 211 211 } 212 212 213 213 - // Value implements [[dbm.Iterator]] 213 213 + // Value implements [dbm.Iterator] 214 214 func (iter *unsavedIterator) Value() []byte { 215 215 return iter.nextVal 216 216 } 217 217 218 218 - // Next implements [[dbm.Iterator]] 218 218 + // Next implements [dbm.Iterator] 219 219 // It's effectively running the constant space overhead algorithm for streaming through sorted lists: 220 220 // the sorted lists being underlying keys & unsavedKeyAdditions / unsavedKeyRemovals 221 221 func (iter *unsavedIterator) Next() { ··· 294 294 iter.nextVal = nil 295 295 } 296 296 297 297 - // Close implements [[dbm.Iterator]] 297 297 + // Close implements [dbm.Iterator] 298 298 func (iter *unsavedIterator) Close() error { 299 299 return stacktrace.Propagate(iter.underlyingIterator.Close(), "") 300 300 } 301 301 302 302 - // Error implements [[dbm.Iterator]] 302 302 + // Error implements [dbm.Iterator] 303 303 func (iter *unsavedIterator) Error() error { 304 304 return iter.err 305 305 }

+46

transaction/write_index_tx.go

··· 1 1 + package transaction 2 2 + 3 3 + import "github.com/palantir/stacktrace" 4 4 + 5 5 + type writeIndexTx struct { 6 6 + db ExtendedDB 7 7 + 8 8 + writeIndex *writeIndex 9 9 + } 10 10 + 11 11 + // Commit implements [WriteIndex]. 12 12 + func (w *writeIndexTx) Commit() error { 13 13 + if w.writeIndex != nil { 14 14 + err := w.writeIndex.Commit() 15 15 + if err != nil { 16 16 + return stacktrace.Propagate(err, "") 17 17 + } 18 18 + } 19 19 + 20 20 + return nil 21 21 + } 22 22 + 23 23 + // Rollback implements [WriteIndex]. 24 24 + func (w *writeIndexTx) Rollback() error { 25 25 + if w.writeIndex != nil { 26 26 + err := w.writeIndex.Rollback() 27 27 + if err != nil { 28 28 + return stacktrace.Propagate(err, "") 29 29 + } 30 30 + } 31 31 + return nil 32 32 + } 33 33 + 34 34 + // IndexDB implements [WriteIndex]. 35 35 + func (w *writeIndexTx) IndexDB() IndexWriter { 36 36 + if w.writeIndex == nil { 37 37 + w.writeIndex = &writeIndex{ 38 38 + batch: w.db.NewBatch(), 39 39 + db: w.db, 40 40 + unsavedAdditions: make(map[string][]byte), 41 41 + unsavedRemovals: make(map[string]struct{}), 42 42 + } 43 43 + } 44 44 + 45 45 + return w.writeIndex 46 46 + }

+3 -4

transaction/write_tx.go

··· 67 67 } 68 68 69 69 // IndexDB implements [Write]. 70 70 - func (w *writeTx) IndexDB() WriteIndex { 70 70 + func (w *writeTx) IndexDB() IndexWriter { 71 71 w.createWriteIndexIfNeeded() 72 72 73 73 return w.writeIndex ··· 82 82 func (w *writeTx) NextSequence() (uint64, error) { 83 83 if !w.hasSeq { 84 84 var err error 85 85 - w.seq, err = w.readTx.sequenceGetter(w.readTx) 85 85 + w.seq, err = w.readTx.operationCounter(w.readTx) 86 86 if err != nil { 87 87 return 0, stacktrace.Propagate(err, "") 88 88 } 89 89 - w.hasSeq = true 90 90 - return w.seq, nil 91 89 } 92 90 93 91 w.seq++ 92 92 + w.hasSeq = true 94 93 return w.seq, nil 95 94 } 96 95