+6 -2

abciapp/app.go

··· 21 21 "tangled.org/gbl08ma.com/didplcbft/plc" 22 22 "tangled.org/gbl08ma.com/didplcbft/store" 23 23 "tangled.org/gbl08ma.com/didplcbft/transaction" 24 24 + "tangled.org/gbl08ma.com/didplcbft/types" 24 25 ) 25 26 26 27 type DIDPLCApplication struct { ··· 30 31 indexDB dbm.DB 31 32 tree *iavl.MutableTree 32 33 fullyClearApplicationData func() error 34 34 + 35 35 + mempoolSubmitter types.MempoolSubmitter 33 36 34 37 validatorPubKey crypto.PubKey 35 38 validatorPrivKey crypto.PrivKey ··· 52 55 } 53 56 54 57 // store and plc must be able to share transaction objects 55 55 - func NewDIDPLCApplication(pv *privval.FilePV, treeDB dbm.DB, indexDB transaction.ExtendedDB, clearData func(), snapshotDirectory, didBloomFilterPath string) (*DIDPLCApplication, *transaction.Factory, plc.PLC, func(), error) { 58 58 + func NewDIDPLCApplication(pv *privval.FilePV, treeDB dbm.DB, indexDB transaction.ExtendedDB, clearData func(), snapshotDirectory, didBloomFilterPath string, mempoolSubmitter types.MempoolSubmitter) (*DIDPLCApplication, *transaction.Factory, plc.PLC, func(), error) { 56 59 mkTree := func() *iavl.MutableTree { 57 60 // Using SpeedDefault appears to cause the processing time for ExecuteOperation to double on average 58 61 // Using SpeedBetterCompression appears to cause the processing time to double again ··· 80 83 runnerContext: runnerContext, 81 84 tree: tree, 82 85 indexDB: indexDB, 86 86 + mempoolSubmitter: mempoolSubmitter, 83 87 snapshotDirectory: snapshotDirectory, 84 88 aocsByPLC: make(map[string]*authoritativeOperationsCache), 85 89 } ··· 201 205 return stacktrace.Propagate(err, "") 202 206 } 203 207 204 204 - d.rangeChallengeCoordinator, err = newRangeChallengeCoordinator(d.runnerContext, d.txFactory, blockStore, d.validatorPubKey, d.validatorPrivKey) 208 208 + d.rangeChallengeCoordinator, err = newRangeChallengeCoordinator(d.runnerContext, d.txFactory, blockStore, d.mempoolSubmitter, d.validatorPubKey, d.validatorPrivKey) 205 209 if err != nil { 206 210 return stacktrace.Propagate(err, "") 207 211 }

+1 -1

abciapp/app_test.go

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

+6 -3

abciapp/block_challenge.go

··· 203 203 } 204 204 205 205 func (c *blockChallengeCoordinator) verifyBlockChallengeProof(height int64, validatorAddress []byte, proofBytes []byte) (bool, error) { 206 206 - tx := c.txFactory.ReadCommitted() 207 207 - if tx.Height() != height-1 { 208 208 - return false, stacktrace.NewError("challenge being verified for unexpected height %d, expected %d", height, tx.Height()+1) 206 206 + // timestamp shouldn't matter for this 207 207 + // it is however important that we read the tree exactly as it was on the height prior to the one where the proof was supposedly generated 208 208 + // this is because operations can change over time (nullification) and also the returned data for the highest operation indexes will be different 209 209 + tx, err := c.txFactory.ReadHeight(time.Time{}, height-1) 210 210 + if err != nil { 211 211 + return false, stacktrace.Propagate(err, "") 209 212 } 210 213 211 214 sharedPart, err := c.fetchOrBuildBlockChallengeCircuitAssignmentShared(tx, height)

+216 -40

abciapp/range_challenge.go

··· 1 1 package abciapp 2 2 3 3 import ( 4 4 - "bytes" 5 4 "context" 6 5 "encoding/binary" 6 6 + "errors" 7 7 "math/big" 8 8 "slices" 9 9 + "time" 9 10 10 11 "github.com/Yiling-J/theine-go" 11 12 "github.com/cometbft/cometbft/crypto" ··· 13 14 "github.com/cosmos/iavl" 14 15 "github.com/cosmos/iavl/db" 15 16 ics23 "github.com/cosmos/ics23/go" 17 17 + cbornode "github.com/ipfs/go-ipld-cbor" 16 18 "github.com/palantir/stacktrace" 19 19 + "github.com/samber/mo" 17 20 "tangled.org/gbl08ma.com/didplcbft/store" 18 21 "tangled.org/gbl08ma.com/didplcbft/transaction" 22 22 + "tangled.org/gbl08ma.com/didplcbft/types" 19 23 ) 20 24 21 25 type rangeChallengeCoordinator struct { ··· 27 31 validatorAddress []byte 28 32 txFactory *transaction.Factory 29 33 nodeBlockStore *bftstore.BlockStore 34 34 + mempoolSubmitter types.MempoolSubmitter 30 35 31 31 - treeCache *theine.LoadingCache[treeCacheKey, cachedTree] 36 36 + treeCache *theine.LoadingCache[treeCacheKey, cachedTree] 37 37 + cachedNextProofFromHeight mo.Option[int64] 32 38 } 33 39 34 34 - func newRangeChallengeCoordinator(runnerContext context.Context, txFactory *transaction.Factory, blockStore *bftstore.BlockStore, pubKey crypto.PubKey, privKey crypto.PrivKey) (*rangeChallengeCoordinator, error) { 40 40 + func newRangeChallengeCoordinator(runnerContext context.Context, txFactory *transaction.Factory, blockStore *bftstore.BlockStore, mempoolSubmitter types.MempoolSubmitter, pubKey crypto.PubKey, privKey crypto.PrivKey) (*rangeChallengeCoordinator, error) { 35 41 c := &rangeChallengeCoordinator{ 36 42 txFactory: txFactory, 37 43 runnerContext: runnerContext, 38 44 nodeBlockStore: blockStore, 45 45 + mempoolSubmitter: mempoolSubmitter, 39 46 isConfiguredToBeValidator: pubKey != nil, 40 47 validatorPubKey: pubKey, 41 48 validatorPrivKey: privKey, ··· 63 70 root []byte 64 71 } 65 72 66 66 - type rangeChallengeProof struct { 67 67 - treeRoot []byte // the tree root we commit to. must be the same between the "commit proof" and the "confirmation proof" 68 68 - membershipProof *ics23.CommitmentProof 69 69 - } 73 73 + func (c *rangeChallengeCoordinator) getOrFetchNextProofFromHeight(tx transaction.Read) (int64, error) { 74 74 + if !c.isConfiguredToBeValidator { 75 75 + return 0, stacktrace.NewError("not configured to be a validator") 76 76 + } 77 77 + if completion, hasCache := c.cachedNextProofFromHeight.Get(); hasCache { 78 78 + return completion, nil 79 79 + } 70 80 71 71 - func (c *rangeChallengeCoordinator) computeRangeChallengeProof(ctx context.Context, tx transaction.Read, startHeight, endHeight, proveHeight int64) (rangeChallengeProof, error) { 72 72 - ctx = context.WithValue(ctx, contextTxKey{}, tx) 73 73 - ct, err := c.treeCache.Get(ctx, treeCacheKey{ 74 74 - startHeight: startHeight, 75 75 - endHeight: endHeight, 76 76 - }) 81 81 + completion, err := store.Consensus.ValidatorRangeChallengeCompletion(tx, c.validatorAddress) 77 82 if err != nil { 78 78 - return rangeChallengeProof{}, stacktrace.Propagate(err, "") 83 83 + if !errors.Is(err, store.ErrNoRecentChallengeCompletion) { 84 84 + return 0, stacktrace.Propagate(err, "") 85 85 + } 86 86 + completion = 0 79 87 } 80 88 81 81 - proofKey := binary.BigEndian.AppendUint64(nil, uint64(proveHeight)) 82 82 - 83 83 - membershipProof, err := ct.tree.GetMembershipProof(proofKey) 89 89 + minProvenBlock := int64(0) 90 90 + for proofHeight := range store.Consensus.BlockChalengeProofsIterator(tx, 0, &err) { 91 91 + minProvenBlock = int64(proofHeight) 92 92 + break 93 93 + } 84 94 if err != nil { 85 85 - return rangeChallengeProof{}, stacktrace.Propagate(err, "") 95 95 + return 0, stacktrace.Propagate(err, "") 86 96 } 87 97 88 88 - return rangeChallengeProof{ 89 89 - treeRoot: ct.root, 90 90 - membershipProof: membershipProof, 91 91 - }, nil 98 98 + minProvable := max(minProvenBlock, int64(completion+1)) 99 99 + 100 100 + c.cachedNextProofFromHeight = mo.Some(minProvable) 101 101 + return minProvable, nil 92 102 } 93 103 94 94 - func verifyMembershipOfRangeChallengeProofs(proofs ...rangeChallengeProof) (bool, error) { 95 95 - if len(proofs) < 1 { 96 96 - return false, stacktrace.NewError("insufficient proofs") 104 104 + func (c *rangeChallengeCoordinator) onNewBlock(ctx context.Context, newBlockHeight int64) error { 105 105 + if !c.isConfiguredToBeValidator { 106 106 + return nil 97 107 } 98 108 99 99 - treeRoot := proofs[0].treeRoot 109 109 + // TODO if ABCI is just replaying old blocks -> do nothing 110 110 + // TODO wait until block is actually committed 111 111 + // ^ solution to both of these problems: don't call this method from the ABCI app, instead, call it from an "outside subscriber" that listens for truly new blocks 100 112 101 101 - for _, proof := range proofs { 102 102 - if !bytes.Equal(proof.treeRoot, treeRoot) { 103 103 - // did not commit to the same root in all proofs 104 104 - return false, nil 113 113 + tx := c.txFactory.ReadCommitted() 114 114 + if tx.Height() < newBlockHeight { 115 115 + // the ABCI app is probably still catching up to new blocks 116 116 + return nil 117 117 + } 118 118 + 119 119 + shouldCommitToChallenge := false 120 120 + shouldCompleteChallenge := false 121 121 + 122 122 + fromHeight, toHeight, provenHeight, includedOnHeight, _, err := store.Consensus.ValidatorRangeChallengeCommitment(tx, c.validatorAddress) 123 123 + if errors.Is(err, store.ErrNoActiveChallengeCommitment) { 124 124 + nextFromHeight, err := c.getOrFetchNextProofFromHeight(tx) 125 125 + if err != nil { 126 126 + return stacktrace.Propagate(err, "") 105 127 } 128 128 + shouldCommitToChallenge = nextFromHeight+CommitToChallengeMinRange+50 <= newBlockHeight 129 129 + } else if err != nil { 130 130 + return stacktrace.Propagate(err, "") 131 131 + } else { 132 132 + commitmentBlockMeta := c.nodeBlockStore.LoadBlockMeta(int64(includedOnHeight)) 133 133 + commitmentExpired := false 134 134 + if commitmentBlockMeta != nil { 135 135 + commitmentExpired = uint64(newBlockHeight) >= includedOnHeight+CompleteChallengeMaxAgeInBlocks || 136 136 + time.Since(commitmentBlockMeta.Header.Time) >= CompleteChallengeMaxAge-1*time.Second 106 137 107 107 - // just use the key and value claimed in the proof as those should have been validated previously 108 108 - if exist := proof.membershipProof.GetExist(); exist != nil { 109 109 - if !ics23.VerifyMembership(ics23.IavlSpec, treeRoot, proof.membershipProof, exist.Key, exist.Value) { 110 110 - return false, nil 111 111 - } 112 112 - } else { 113 113 - return false, stacktrace.NewError("proof is not an existence proof") 138 138 + // shouldCompleteChallenge if not too many blocks have passed AND enough blocks have passed 139 139 + shouldCompleteChallenge = !commitmentExpired && includedOnHeight+1 <= uint64(newBlockHeight) 140 140 + } 141 141 + 142 142 + if !shouldCompleteChallenge { 143 143 + shouldCommitToChallenge = commitmentExpired 114 144 } 115 145 } 116 146 117 117 - return true, nil 147 147 + var transactionBytes []byte 148 148 + if shouldCompleteChallenge { 149 149 + transactionBytes, err = c.createCompleteChallengeTx(ctx, tx, int64(fromHeight), int64(toHeight), int64(provenHeight), int64(includedOnHeight)) 150 150 + if err != nil { 151 151 + return stacktrace.Propagate(err, "") 152 152 + } 153 153 + } else if shouldCommitToChallenge { 154 154 + transactionBytes, err = c.createCommitToChallengeTx(ctx, tx, newBlockHeight) 155 155 + if err != nil { 156 156 + return stacktrace.Propagate(err, "") 157 157 + } 158 158 + } 159 159 + 160 160 + _, err = c.mempoolSubmitter.BroadcastTxCommit(ctx, transactionBytes) 161 161 + if err != nil { 162 162 + return stacktrace.Propagate(err, "") 163 163 + } 164 164 + c.cachedNextProofFromHeight = mo.None[int64]() 165 165 + return nil 118 166 } 119 167 120 120 - func computeHeightToProveInRange(lastCommitHash, validatorAddress []byte, fromHeight, toHeight int64) uint64 { 168 168 + func (c *rangeChallengeCoordinator) createCommitToChallengeTx(ctx context.Context, tx transaction.Read, toHeight int64) ([]byte, error) { 169 169 + if !c.isConfiguredToBeValidator { 170 170 + return nil, stacktrace.NewError("not configured to be validator") 171 171 + } 172 172 + 173 173 + fromHeight, err := c.getOrFetchNextProofFromHeight(tx) 174 174 + if err != nil { 175 175 + return nil, stacktrace.Propagate(err, "") 176 176 + } 177 177 + 178 178 + if toHeight < fromHeight+CommitToChallengeMinRange { 179 179 + return nil, stacktrace.NewError("insufficient blocks passed") 180 180 + } 181 181 + 182 182 + if toHeight > fromHeight+CommitToChallengeMaxRange { 183 183 + fromHeight = toHeight - CommitToChallengeMaxRange 184 184 + } 185 185 + 186 186 + pubKeyArg, err := MarshalPubKeyForArguments(c.validatorPubKey) 187 187 + if err != nil { 188 188 + return nil, stacktrace.Propagate(err, "") 189 189 + } 190 190 + 191 191 + toHeightBlockMeta := c.nodeBlockStore.LoadBlockMeta(toHeight) 192 192 + if toHeightBlockMeta == nil { 193 193 + return nil, stacktrace.NewError("block not found at height") 194 194 + } 195 195 + 196 196 + if time.Since(toHeightBlockMeta.Header.Time) > CommitToChallengeMaxAge { 197 197 + return nil, stacktrace.NewError("too much time passed since block at height") 198 198 + } 199 199 + 200 200 + proveHeight := computeHeightToProveInRange(toHeightBlockMeta.Header.LastCommitHash, c.validatorAddress, int64(fromHeight), int64(toHeight), mo.None[int64]()) 201 201 + 202 202 + commitToRoot, membershipProof, err := c.computeRangeChallengeProof(ctx, tx, fromHeight, toHeight, proveHeight) 203 203 + if err != nil { 204 204 + return nil, stacktrace.Propagate(err, "") 205 205 + } 206 206 + 207 207 + proofBytes, err := membershipProof.Marshal() 208 208 + if err != nil { 209 209 + return nil, stacktrace.Propagate(err, "") 210 210 + } 211 211 + 212 212 + transaction := Transaction[CommitToChallengeArguments]{ 213 213 + Action: TransactionActionCommitToChallenge, 214 214 + Arguments: CommitToChallengeArguments{ 215 215 + ValidatorPubKey: pubKeyArg, 216 216 + FromHeight: int64(fromHeight), 217 217 + ToHeight: int64(toHeight), 218 218 + Root: commitToRoot, 219 219 + Proof: proofBytes, 220 220 + }, 221 221 + } 222 222 + 223 223 + transaction, err = SignTransaction(c.validatorPrivKey, transaction) 224 224 + if err != nil { 225 225 + return nil, stacktrace.Propagate(err, "") 226 226 + } 227 227 + 228 228 + out, err := cbornode.DumpObject(transaction) 229 229 + if err != nil { 230 230 + return nil, stacktrace.Propagate(err, "") 231 231 + } 232 232 + return out, nil 233 233 + } 234 234 + 235 235 + func (c *rangeChallengeCoordinator) createCompleteChallengeTx(ctx context.Context, tx transaction.Read, fromHeight, toHeight, prevProvenHeight, commitmentIncludedOnHeight int64) ([]byte, error) { 236 236 + if !c.isConfiguredToBeValidator { 237 237 + return nil, stacktrace.NewError("not configured to be validator") 238 238 + } 239 239 + 240 240 + nextBlockMeta := c.nodeBlockStore.LoadBlockMeta(commitmentIncludedOnHeight + 1) 241 241 + if nextBlockMeta == nil { 242 242 + return nil, stacktrace.NewError("block not found at height") 243 243 + } 244 244 + 245 245 + proveHeight := computeHeightToProveInRange(nextBlockMeta.Header.LastCommitHash, c.validatorAddress, int64(fromHeight), int64(toHeight), mo.Some(prevProvenHeight)) 246 246 + 247 247 + _, membershipProof, err := c.computeRangeChallengeProof(ctx, tx, fromHeight, toHeight, proveHeight) 248 248 + if err != nil { 249 249 + return nil, stacktrace.Propagate(err, "") 250 250 + } 251 251 + 252 252 + proofBytes, err := membershipProof.Marshal() 253 253 + if err != nil { 254 254 + return nil, stacktrace.Propagate(err, "") 255 255 + } 256 256 + 257 257 + transaction := Transaction[CompleteChallengeArguments]{ 258 258 + Action: TransactionActionCompleteChallenge, 259 259 + Arguments: CompleteChallengeArguments{ 260 260 + Validator: c.validatorAddress, 261 261 + Proof: proofBytes, 262 262 + }, 263 263 + } 264 264 + 265 265 + out, err := cbornode.DumpObject(transaction) 266 266 + if err != nil { 267 267 + return nil, stacktrace.Propagate(err, "") 268 268 + } 269 269 + return out, nil 270 270 + } 271 271 + 272 272 + func (c *rangeChallengeCoordinator) computeRangeChallengeProof(ctx context.Context, tx transaction.Read, startHeight, endHeight, proveHeight int64) ([]byte, *ics23.CommitmentProof, error) { 273 273 + ctx = context.WithValue(ctx, contextTxKey{}, tx) 274 274 + ct, err := c.treeCache.Get(ctx, treeCacheKey{ 275 275 + startHeight: startHeight, 276 276 + endHeight: endHeight, 277 277 + }) 278 278 + if err != nil { 279 279 + return nil, nil, stacktrace.Propagate(err, "") 280 280 + } 281 281 + 282 282 + proofKey := binary.BigEndian.AppendUint64(nil, uint64(proveHeight)) 283 283 + 284 284 + membershipProof, err := ct.tree.GetMembershipProof(proofKey) 285 285 + if err != nil { 286 286 + return nil, nil, stacktrace.Propagate(err, "") 287 287 + } 288 288 + 289 289 + return ct.root, membershipProof, nil 290 290 + } 291 291 + 292 292 + func computeHeightToProveInRange(lastCommitHash, validatorAddress []byte, fromHeight, toHeight int64, avoidHeight mo.Option[int64]) int64 { 121 293 lastCommitHashBigInt := new(big.Int).SetBytes(lastCommitHash) 122 294 validatorBigInt := new(big.Int).SetBytes(validatorAddress) 123 295 seed := new(big.Int).Xor(lastCommitHashBigInt, validatorBigInt) ··· 126 298 127 299 randOffset := new(big.Int).Mod(seed, big.NewInt(numBlocks)) 128 300 129 129 - return uint64(fromHeight) + randOffset.Uint64() 301 301 + candidateHeight := fromHeight + int64(randOffset.Uint64()) 302 302 + if h, ok := avoidHeight.Get(); ok && candidateHeight == h { 303 303 + candidateHeight = (candidateHeight + 1) % int64(numBlocks) 304 304 + } 305 305 + return candidateHeight 130 306 } 131 307 132 308 func (c *rangeChallengeCoordinator) proofTreeLoader(ctx context.Context, cacheKey treeCacheKey) (theine.Loaded[cachedTree], error) {

+4 -4

abciapp/snapshots.go

··· 382 382 } 383 383 384 384 func exportIndexEntries(indexDB dbm.DB, treeVersion int64, w io.Writer) (int64, error) { 385 385 - didLogKeyStart := make([]byte, store.DIDLogKeySize) 386 386 - didLogKeyStart[0] = store.DIDLogKeyPrefix 387 387 - didLogKeyEnd := slices.Repeat([]byte{0xff}, store.DIDLogKeySize) 388 388 - didLogKeyEnd[0] = store.DIDLogKeyPrefix 385 385 + didLogKeyStart := make([]byte, store.IndexDIDLogKeyLength) 386 386 + didLogKeyStart[0] = store.IndexDIDLogKeyPrefix 387 387 + didLogKeyEnd := slices.Repeat([]byte{0xff}, store.IndexDIDLogKeyLength) 388 388 + didLogKeyEnd[0] = store.IndexDIDLogKeyPrefix 389 389 390 390 iterator, err := indexDB.Iterator(didLogKeyStart, didLogKeyEnd) 391 391 if err != nil {

+156 -25

abciapp/tx_challenge.go

··· 3 3 import ( 4 4 "context" 5 5 "encoding/binary" 6 6 + "errors" 6 7 "time" 7 8 8 9 ics23 "github.com/cosmos/ics23/go" 9 10 cbornode "github.com/ipfs/go-ipld-cbor" 10 11 "github.com/palantir/stacktrace" 11 12 "github.com/samber/lo" 13 13 + "github.com/samber/mo" 14 14 + "tangled.org/gbl08ma.com/didplcbft/store" 12 15 ) 13 16 14 17 var TransactionActionCommitToChallenge = registerTransactionAction[CommitToChallengeArguments]("CommitToChallenge", processCommitToChallengeTx) ··· 19 22 20 23 var CommitToChallengeMaxAge = lo.Must(time.ParseDuration("10s")) 21 24 25 25 + const CompleteChallengeMaxAgeInBlocks = 3 26 26 + 27 27 + var CompleteChallengeMaxAge = lo.Must(time.ParseDuration("10s")) 28 28 + 22 29 type CommitToChallengeArguments struct { 23 30 ValidatorPubKey PubKeyInArguments `json:"validator" refmt:"validator"` 24 31 FromHeight int64 `json:"fromHeight" refmt:"fromHeight"` 25 32 26 26 - // ToHeight should not be more than N blocks behind the block where this transaction is included 27 27 - // (i.e. this transaction "expires" once ToHeight is more than N blocks old, and shouldn't be included after that) 33 33 + // ToHeight should not be more than CommitToChallengeMaxAgeInBlocks behind the block where this transaction is included 34 34 + // (i.e. this transaction "expires" once ToHeight is more than CommitToChallengeMaxAgeInBlocks blocks old, and shouldn't be included after that) 28 35 ToHeight int64 `json:"toHeight" refmt:"toHeight"` 29 36 Root []byte `json:"root" refmt:"root"` 30 37 Proof []byte `json:"proof" refmt:"proof"` ··· 62 69 63 70 validatorAddress := validatorPubKey.Address() 64 71 65 65 - if tx.Arguments.ToHeight < tx.Arguments.FromHeight { 72 72 + if tx.Arguments.ToHeight < tx.Arguments.FromHeight || tx.Arguments.ToHeight >= deps.workingHeight { 66 73 return &processResult{ 67 74 Code: 4201, 68 75 Info: "invalid challenge range", ··· 105 112 }, nil 106 113 } 107 114 115 115 + currentCompletion, err := store.Consensus.ValidatorRangeChallengeCompletion(deps.readTx, validatorAddress) 116 116 + if err == nil { 117 117 + if tx.Arguments.FromHeight <= int64(currentCompletion) { 118 118 + return &processResult{ 119 119 + Code: 4207, 120 120 + Info: "challenge range overlaps already completed challenge", 121 121 + }, nil 122 122 + } 123 123 + } else if !errors.Is(err, store.ErrNoRecentChallengeCompletion) { 124 124 + return nil, stacktrace.Propagate(err, "") 125 125 + } 126 126 + 127 127 + if len(tx.Arguments.Root) != 32 { 128 128 + return &processResult{ 129 129 + Code: 4208, 130 130 + Info: "invalid root", 131 131 + }, nil 132 132 + } 133 133 + 108 134 proof := new(ics23.CommitmentProof) 109 135 err = proof.Unmarshal(tx.Arguments.Proof) 110 136 if err != nil || proof.GetExist() == nil { 111 137 return &processResult{ 112 112 - Code: 4207, 138 138 + Code: 4209, 113 139 Info: "invalid proof", 114 140 }, nil 115 141 } 116 142 existenceProof := proof.GetExist() 117 143 118 118 - proofHeight := binary.BigEndian.Uint64(existenceProof.Key) 144 144 + proofHeight := int64(binary.BigEndian.Uint64(existenceProof.Key)) 119 145 120 146 expectedProofHeight := computeHeightToProveInRange( 121 147 toHeightBlockMeta.Header.LastCommitHash.Bytes(), 122 148 validatorAddress.Bytes(), 123 149 tx.Arguments.FromHeight, 124 124 - tx.Arguments.ToHeight) 150 150 + tx.Arguments.ToHeight, 151 151 + mo.None[int64]()) 125 152 126 153 if proofHeight != expectedProofHeight { 127 154 return &processResult{ 128 128 - Code: 4208, 155 155 + Code: 4210, 129 156 Info: "invalid proof", 130 157 }, nil 131 158 } ··· 136 163 } 137 164 if !blockProofValid { 138 165 return &processResult{ 139 139 - Code: 4209, 166 166 + Code: 4211, 140 167 Info: "invalid proof", 141 168 }, nil 142 169 } 143 170 144 144 - rangeProof := rangeChallengeProof{ 145 145 - treeRoot: tx.Arguments.Root, 146 146 - membershipProof: proof, 147 147 - } 148 148 - 149 149 - rangeProofValid, err := verifyMembershipOfRangeChallengeProofs(rangeProof) 150 150 - if err != nil { 151 151 - return nil, stacktrace.Propagate(err, "") 152 152 - } 153 153 - if !rangeProofValid { 171 171 + if !ics23.VerifyMembership(ics23.IavlSpec, tx.Arguments.Root, proof, existenceProof.Key, existenceProof.Value) { 154 172 return &processResult{ 155 155 - Code: 4210, 173 173 + Code: 4212, 156 174 Info: "invalid proof", 157 175 }, nil 158 176 } 159 177 160 178 if writeTx, ok := deps.writeTx.Get(); ok { 161 161 - // TODO set challenge commit state for this validator in tree 162 162 - _ = writeTx 163 163 - return nil, stacktrace.NewError("not implemented") // TODO 179 179 + err = store.Consensus.SetValidatorRangeChallengeCommitment( 180 180 + writeTx, 181 181 + validatorAddress, 182 182 + uint64(tx.Arguments.FromHeight), 183 183 + uint64(tx.Arguments.ToHeight), 184 184 + uint64(proofHeight), 185 185 + uint64(deps.workingHeight), 186 186 + tx.Arguments.Root) 187 187 + if err != nil { 188 188 + return nil, stacktrace.Propagate(err, "") 189 189 + } 164 190 } 165 191 166 192 return &processResult{ ··· 171 197 var TransactionActionCompleteChallenge = registerTransactionAction[CompleteChallengeArguments]("CompleteChallenge", processCompleteChallengeTx) 172 198 173 199 type CompleteChallengeArguments struct { 200 200 + // This transaction is not signed. It is a no-op if it isn't valid and we don't really care if an entity is able to complete a challenge on behalf of another validator 201 201 + // (that would be quite an achievement, on the level of a validator being able to find a collision for the committed root in order to fake not doing all the work) 174 202 Validator []byte `json:"validator" refmt:"validator"` 175 203 176 204 // this shall be a membership proof on the same tree the validator previously committed to, 177 205 // for the key deterministically-randomly determined by the last_commit_hash of the block _after_ the one 178 206 // where the most recent CommitToChallenge transaction for this validator got included 179 179 - // this transaction must be included within N blocks after the inclusion of that CommitToChallenge transaction 180 180 - // TODO determine N 207 207 + // this transaction must be included within CompleteChallengeMaxAgeInBlocks blocks after the inclusion of that CommitToChallenge transaction 181 208 Proof []byte `json:"proof" refmt:"proof"` 182 209 } 183 210 ··· 191 218 } 192 219 193 220 func processCompleteChallengeTx(ctx context.Context, deps TransactionProcessorDependencies, txBytes []byte) (*processResult, error) { 194 194 - return nil, stacktrace.NewError("not implemented") // TODO 221 221 + tx, err := UnmarshalTransaction[CompleteChallengeArguments](txBytes) 222 222 + if err != nil { 223 223 + return &processResult{ 224 224 + Code: 4000, 225 225 + Info: err.Error(), 226 226 + }, nil 227 227 + } 228 228 + 229 229 + fromHeight, toHeight, provenHeight, includedOnHeight, committedTreeRoot, err := store.Consensus.ValidatorRangeChallengeCommitment(deps.readTx, tx.Arguments.Validator) 230 230 + if err != nil { 231 231 + if errors.Is(err, store.ErrNoActiveChallengeCommitment) { 232 232 + return &processResult{ 233 233 + Code: 4300, 234 234 + Info: "validator is not committed to a challenge", 235 235 + }, nil 236 236 + } 237 237 + return nil, stacktrace.Propagate(err, "") 238 238 + } 239 239 + 240 240 + if int64(includedOnHeight)+CompleteChallengeMaxAgeInBlocks < deps.workingHeight { 241 241 + // validator must commit to a new challenge 242 242 + return &processResult{ 243 243 + Code: 4301, 244 244 + Info: "outdated challenge commitment", 245 245 + }, nil 246 246 + } 247 247 + 248 248 + includedHeightBlockMeta := deps.blockStore.LoadBlockMeta(int64(includedOnHeight)) 249 249 + if includedHeightBlockMeta == nil { 250 250 + // this shouldn't happen unless the prover is submitting the completion on the same block as the commitment 251 251 + return &processResult{ 252 252 + Code: 4302, 253 253 + Info: "premature challenge completion", 254 254 + }, nil 255 255 + } 256 256 + 257 257 + if time.Since(includedHeightBlockMeta.Header.Time) > CompleteChallengeMaxAge { 258 258 + // validator must commit to a new challenge 259 259 + return &processResult{ 260 260 + Code: 4303, 261 261 + Info: "outdated challenge commitment", 262 262 + }, nil 263 263 + } 264 264 + 265 265 + proof := new(ics23.CommitmentProof) 266 266 + err = proof.Unmarshal(tx.Arguments.Proof) 267 267 + if err != nil || proof.GetExist() == nil { 268 268 + return &processResult{ 269 269 + Code: 4304, 270 270 + Info: "invalid proof", 271 271 + }, nil 272 272 + } 273 273 + existenceProof := proof.GetExist() 274 274 + 275 275 + proofHeight := int64(binary.BigEndian.Uint64(existenceProof.Key)) 276 276 + 277 277 + expectedProofHeight := computeHeightToProveInRange( 278 278 + includedHeightBlockMeta.Header.LastCommitHash.Bytes(), 279 279 + tx.Arguments.Validator, 280 280 + int64(fromHeight), 281 281 + int64(toHeight), 282 282 + mo.Some(int64(provenHeight))) 283 283 + 284 284 + if proofHeight != expectedProofHeight { 285 285 + return &processResult{ 286 286 + Code: 4305, 287 287 + Info: "incorrect key proven", 288 288 + }, nil 289 289 + } 290 290 + 291 291 + blockProofValid, err := deps.blockChallengeCoordinator.verifyBlockChallengeProof(int64(proofHeight), tx.Arguments.Validator, existenceProof.Value) 292 292 + if err != nil { 293 293 + return nil, stacktrace.Propagate(err, "") 294 294 + } 295 295 + if !blockProofValid { 296 296 + return &processResult{ 297 297 + Code: 4306, 298 298 + Info: "invalid proof", 299 299 + }, nil 300 300 + } 301 301 + 302 302 + if !ics23.VerifyMembership(ics23.IavlSpec, committedTreeRoot, proof, existenceProof.Key, existenceProof.Value) { 303 303 + return &processResult{ 304 304 + Code: 4307, 305 305 + Info: "invalid proof", 306 306 + }, nil 307 307 + } 308 308 + 309 309 + if writeTx, ok := deps.writeTx.Get(); ok { 310 310 + err = store.Consensus.ClearValidatorRangeChallengeCommitment(writeTx, tx.Arguments.Validator) 311 311 + if err != nil { 312 312 + return nil, stacktrace.Propagate(err, "") 313 313 + } 314 314 + 315 315 + err = store.Consensus.SetValidatorRangeChallengeCompletion(writeTx, tx.Arguments.Validator, toHeight) 316 316 + if err != nil { 317 317 + return nil, stacktrace.Propagate(err, "") 318 318 + } 319 319 + 320 320 + // TODO effects on validator reputation 321 321 + } 322 322 + 323 323 + return &processResult{ 324 324 + Code: 0, 325 325 + }, nil 195 326 }

+27 -18

httpapi/broadcast.go tx_submitter.go

··· 1 1 - package httpapi 1 1 + package main 2 2 3 3 import ( 4 4 "context" 5 5 - "time" 6 5 7 6 abci "github.com/cometbft/cometbft/abci/types" 8 7 mempl "github.com/cometbft/cometbft/mempool" 9 8 "github.com/cometbft/cometbft/node" 10 9 "github.com/cometbft/cometbft/rpc/core" 11 11 - ctypes "github.com/cometbft/cometbft/rpc/core/types" 12 12 - "github.com/cometbft/cometbft/types" 10 10 + coretypes "github.com/cometbft/cometbft/rpc/core/types" 11 11 + cmttypes "github.com/cometbft/cometbft/types" 12 12 + "github.com/google/uuid" 13 13 "github.com/palantir/stacktrace" 14 14 + "tangled.org/gbl08ma.com/didplcbft/types" 14 15 ) 15 16 16 16 - func broadcastTxCommit(ctx context.Context, node *node.Node, subscriber string, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { 17 17 - eventBus := node.EventBus() 18 18 - mempool := node.Mempool() 17 17 + type txSubmitter struct { 18 18 + node *node.Node 19 19 + } 20 20 + 21 21 + var _ types.MempoolSubmitter = (*txSubmitter)(nil) 22 22 + 23 23 + // BroadcastTxCommit implements [types.MempoolSubmitter]. 24 24 + func (t *txSubmitter) BroadcastTxCommit(ctx context.Context, tx cmttypes.Tx) (*coretypes.ResultBroadcastTxCommit, error) { 25 25 + uuid, err := uuid.NewRandom() 26 26 + if err != nil { 27 27 + return nil, stacktrace.Propagate(err, "") 28 28 + } 29 29 + subscriber := uuid.String() 30 30 + eventBus := t.node.EventBus() 31 31 + mempool := t.node.Mempool() 19 32 // Subscribe to tx being committed in block. 20 33 subCtx, cancel := context.WithTimeout(ctx, core.SubscribeTimeout) 21 34 defer cancel() 22 22 - q := types.EventQueryTxFor(tx) 35 35 + q := cmttypes.EventQueryTxFor(tx) 23 36 txSub, err := eventBus.Subscribe(subCtx, subscriber, q) 24 37 if err != nil { 25 38 return nil, stacktrace.Propagate(err, "failed to subscribe to tx") ··· 45 58 return nil, stacktrace.Propagate(ctx.Err(), "broadcast confirmation not received") 46 59 case checkTxRes := <-checkTxResCh: 47 60 if checkTxRes.Code != abci.CodeTypeOK { 48 48 - return &ctypes.ResultBroadcastTxCommit{ 61 61 + return &coretypes.ResultBroadcastTxCommit{ 49 62 CheckTx: *checkTxRes, 50 63 TxResult: abci.ExecTxResult{}, 51 64 Hash: tx.Hash(), ··· 54 67 55 68 // Wait for the tx to be included in a block or timeout. 56 69 select { 70 70 + case <-ctx.Done(): 71 71 + return nil, stacktrace.Propagate(ctx.Err(), "inclusion confirmation not received") 57 72 case msg := <-txSub.Out(): // The tx was included in a block. 58 58 - txResultEvent := msg.Data().(types.EventDataTx) 59 59 - return &ctypes.ResultBroadcastTxCommit{ 73 73 + txResultEvent := msg.Data().(cmttypes.EventDataTx) 74 74 + return &coretypes.ResultBroadcastTxCommit{ 60 75 CheckTx: *checkTxRes, 61 76 TxResult: txResultEvent.Result, 62 77 Hash: tx.Hash(), ··· 67 82 if err == nil { 68 83 err = stacktrace.NewError("CometBFT exited") 69 84 } 70 70 - return &ctypes.ResultBroadcastTxCommit{ 85 85 + return &coretypes.ResultBroadcastTxCommit{ 71 86 CheckTx: *checkTxRes, 72 87 TxResult: abci.ExecTxResult{}, 73 88 Hash: tx.Hash(), 74 89 }, stacktrace.Propagate(err, "txSub was canceled") 75 75 - case <-time.After(node.Config().RPC.TimeoutBroadcastTxCommit): 76 76 - return &ctypes.ResultBroadcastTxCommit{ 77 77 - CheckTx: *checkTxRes, 78 78 - TxResult: abci.ExecTxResult{}, 79 79 - Hash: tx.Hash(), 80 80 - }, stacktrace.NewError("timed out waiting for tx to be included in a block") 81 90 } 82 91 } 83 92 }

+19 -25

httpapi/server.go

··· 17 17 "time" 18 18 19 19 "github.com/bluesky-social/indigo/atproto/atcrypto" 20 20 - "github.com/cometbft/cometbft/node" 21 20 "github.com/did-method-plc/go-didplc" 22 22 - "github.com/google/uuid" 23 21 cbornode "github.com/ipfs/go-ipld-cbor" 24 22 "github.com/palantir/stacktrace" 25 23 "github.com/rs/cors" ··· 28 26 "tangled.org/gbl08ma.com/didplcbft/abciapp" 29 27 "tangled.org/gbl08ma.com/didplcbft/plc" 30 28 "tangled.org/gbl08ma.com/didplcbft/transaction" 29 29 + "tangled.org/gbl08ma.com/didplcbft/types" 31 30 ) 32 31 33 32 // Server represents the HTTP server for the PLC directory. 34 33 type Server struct { 35 35 - txFactory *transaction.Factory 36 36 - plc plc.ReadPLC 37 37 - router *http.ServeMux 38 38 - node *node.Node 39 39 - srv http.Server 40 40 - handlerTimeout time.Duration 41 41 - proto string 42 42 - addr string 34 34 + txFactory *transaction.Factory 35 35 + plc plc.ReadPLC 36 36 + router *http.ServeMux 37 37 + mempoolSubmitter types.MempoolSubmitter 38 38 + srv http.Server 39 39 + handlerTimeout time.Duration 40 40 + proto string 41 41 + addr string 43 42 44 43 started atomic.Bool 45 44 exitDone sync.WaitGroup 46 45 } 47 46 48 47 // NewServer creates a new instance of the Server. 49 49 - func NewServer(txFactory *transaction.Factory, plc plc.ReadPLC, node *node.Node, listenAddr string, handlerTimeout time.Duration) (*Server, error) { 48 48 + func NewServer(txFactory *transaction.Factory, plc plc.ReadPLC, mempoolSubmitter types.MempoolSubmitter, listenAddr string, handlerTimeout time.Duration) (*Server, error) { 50 49 s := &Server{ 51 51 - txFactory: txFactory, 52 52 - plc: plc, 53 53 - router: http.NewServeMux(), 54 54 - node: node, 55 55 - srv: http.Server{Addr: listenAddr}, 56 56 - handlerTimeout: handlerTimeout, 50 50 + txFactory: txFactory, 51 51 + plc: plc, 52 52 + router: http.NewServeMux(), 53 53 + mempoolSubmitter: mempoolSubmitter, 54 54 + srv: http.Server{Addr: listenAddr}, 55 55 + handlerTimeout: handlerTimeout, 57 56 } 58 57 s.setupRoutes() 59 58 ··· 199 198 return 200 199 } 201 200 202 202 - if s.node == nil { 201 201 + if s.mempoolSubmitter == nil { 203 202 // Validate only 204 203 // Marshal the operation to JSON bytes for validation 205 204 opBytes, err := json.Marshal(op) ··· 216 215 return 217 216 } 218 217 219 219 - uuid, err := uuid.NewRandom() 220 220 - if handlePLCError(w, err, "") { 221 221 - return 222 222 - } 223 223 - 224 218 tx := abciapp.Transaction[abciapp.CreatePlcOpArguments]{ 225 219 Action: abciapp.TransactionActionCreatePlcOp, 226 220 Arguments: abciapp.CreatePlcOpArguments{ ··· 234 228 return 235 229 } 236 230 237 237 - // broadcastTxCommit will wait for inclusion, up until the TimeoutBroadcastTxCommit configured for the node, or until the context deadline expires 231 231 + // broadcastTxCommit will wait for inclusion until the context deadline expires 238 232 // in practice we expect operations to be included in about one second 239 239 - result, err := broadcastTxCommit(r.Context(), s.node, uuid.String(), txBytes) 233 233 + result, err := s.mempoolSubmitter.BroadcastTxCommit(r.Context(), txBytes) 240 234 // TODO more robust error handling 241 235 if handlePLCError(w, err, "") { 242 236 return

+6 -2

main.go

··· 90 90 os.Remove(didBloomFilterPath) 91 91 } 92 92 93 93 + mempoolSubmitter := &txSubmitter{} 94 94 + 93 95 pv := privval.LoadFilePV( 94 96 config.PrivValidatorKeyFile(), 95 97 config.PrivValidatorStateFile(), 96 98 ) 97 99 98 98 - app, txFactory, plc, cleanup, err := abciapp.NewDIDPLCApplication(pv, treeDB, indexDB, recreateDatabases, filepath.Join(homeDir, "snapshots"), didBloomFilterPath) 100 100 + app, txFactory, plc, cleanup, err := abciapp.NewDIDPLCApplication(pv, treeDB, indexDB, recreateDatabases, filepath.Join(homeDir, "snapshots"), didBloomFilterPath, mempoolSubmitter) 99 101 if err != nil { 100 102 log.Fatalf("failed to create DIDPLC application: %v", err) 101 103 } ··· 128 130 log.Fatalf("Creating node: %v", err) 129 131 } 130 132 133 133 + mempoolSubmitter.node = node 134 134 + 131 135 err = app.FinishInitializing(node.BlockStore()) 132 136 if err != nil { 133 137 log.Fatalf("Finishing ABCI app initialization: %v", err) ··· 143 147 }() 144 148 145 149 if config.PLC.ListenAddress != "" { 146 146 - plcAPIServer, err := httpapi.NewServer(txFactory, plc, node, config.PLC.ListenAddress, 30*time.Second) 150 150 + plcAPIServer, err := httpapi.NewServer(txFactory, plc, mempoolSubmitter, config.PLC.ListenAddress, 30*time.Second) 147 151 if err != nil { 148 152 log.Fatalf("Creating PLC API server: %v", err) 149 153 }

+130 -14

store/consensus.go

··· 5 5 _ "embed" 6 6 "encoding/base32" 7 7 "encoding/binary" 8 8 + "errors" 8 9 "iter" 9 10 "math" 10 11 "slices" ··· 24 25 "tangled.org/gbl08ma.com/didplcbft/types" 25 26 ) 26 27 28 28 + const ( 29 29 + TreeOperationKeyPrefix = 'o' 30 30 + TreeOperationKeyLength = 1 + 8 31 31 + TreeRangeChallengeCommitmentKeyPrefix = 'C' 32 32 + TreeRangeChallengeKeyLength = 1 + 20 33 33 + TreeChallengeCompletionKeyPrefix = 'p' 34 34 + TreeChallengeCompletionKeyLength = 1 + 20 35 35 + 36 36 + IndexBlockChallengeKeyPrefix = 'c' 37 37 + IndexBlockChallengeKeyLength = 1 + 8 38 38 + IndexDIDLogKeyPrefix = 'l' 39 39 + IndexDIDLogKeyLength = 1 + 15 + 8 40 40 + 41 41 + TreeAuthoritativePLCKey = "aPLCURL" 42 42 + TreeAuthoritativeImportProgressKey = "aImportProgress" 43 43 + ) 44 44 + 27 45 var Consensus ConsensusStore = &consensusStore{} 46 46 + 47 47 + var ErrNoActiveChallengeCommitment = errors.New("the validator is currently not committed to a challenge") 48 48 + var ErrNoRecentChallengeCompletion = errors.New("the validator has not completed a range challenge recently") 28 49 29 50 // ConsensusStore manages all information that is directly or indirectly protected by consensus 30 51 type ConsensusStore interface { ··· 44 65 45 66 AuthoritativeImportProgress(tx transaction.Read) (uint64, error) 46 67 SetAuthoritativeImportProgress(tx transaction.Write, nextCursor uint64) error 68 68 + 69 69 + ValidatorRangeChallengeCommitment(tx transaction.Read, validatorAddress []byte) (fromHeight, toHeight, provenHeight, includedOnHeight uint64, treeRoot []byte, err error) 70 70 + SetValidatorRangeChallengeCommitment(tx transaction.Write, validatorAddress []byte, fromHeight, toHeight, provenHeight, includedOnHeight uint64, treeRoot []byte) error 71 71 + ClearValidatorRangeChallengeCommitment(tx transaction.Write, validatorAddress []byte) error 72 72 + 73 73 + ValidatorRangeChallengeCompletion(tx transaction.Read, validatorAddress []byte) (uint64, error) 74 74 + SetValidatorRangeChallengeCompletion(tx transaction.Write, validatorAddress []byte, completedToHeight uint64) error 47 75 48 76 BlockChallengeProof(tx transaction.Read, height uint64) ([]byte, error) 49 77 BlockChalengeProofsIterator(tx transaction.Read, afterHeight uint64, retErr *error) iter.Seq2[uint64, []byte] // afterHeight is exclusive for consistency with OperationsIterator ··· 201 229 func (t *consensusStore) ExportOperations(ctx context.Context, tx transaction.Read, after uint64, count int) ([]types.SequencedLogEntry, error) { 202 230 entries := make([]types.SequencedLogEntry, 0, count) 203 231 var iterErr error 204 204 - for logEntry, _ := range t.OperationsIterator(tx, after, &iterErr) { 232 232 + for logEntry := range t.OperationsIterator(tx, after, &iterErr) { 205 233 entries = append(entries, logEntry) 206 234 207 235 // this condition being checked here also makes it so that a count of zero means unlimited ··· 431 459 return did, nil 432 460 } 433 461 434 434 - const DIDLogKeySize = 1 + 15 + 8 435 435 - const DIDLogKeyPrefix = 'l' 436 436 - 437 462 func marshalDIDLogKey(didBytes []byte, sequence uint64) []byte { 438 438 - key := make([]byte, DIDLogKeySize) 439 439 - key[0] = DIDLogKeyPrefix 463 463 + key := make([]byte, IndexDIDLogKeyLength) 464 464 + key[0] = IndexDIDLogKeyPrefix 440 465 copy(key[1:16], didBytes) 441 466 binary.BigEndian.PutUint64(key[16:], sequence) 442 467 return key ··· 461 486 } 462 487 463 488 func marshalOperationKey(sequence uint64) []byte { 464 464 - key := make([]byte, 1+8) 465 465 - key[0] = 'o' 489 489 + key := make([]byte, TreeOperationKeyLength) 490 490 + key[0] = TreeOperationKeyPrefix 466 491 467 492 binary.BigEndian.PutUint64(key[1:], sequence) 468 493 ··· 588 613 } 589 614 590 615 func (t *consensusStore) AuthoritativePLC(tx transaction.Read) (string, error) { 591 591 - url, err := tx.Tree().Get([]byte("aPLCURL")) 616 616 + url, err := tx.Tree().Get([]byte(TreeAuthoritativePLCKey)) 592 617 if err != nil { 593 618 return "", stacktrace.Propagate(err, "") 594 619 } ··· 599 624 } 600 625 601 626 func (t *consensusStore) SetAuthoritativePLC(tx transaction.Write, url string) error { 602 602 - _, err := tx.Tree().Set([]byte("aPLCURL"), []byte(url)) 627 627 + _, err := tx.Tree().Set([]byte(TreeAuthoritativePLCKey), []byte(url)) 603 628 return stacktrace.Propagate(err, "") 604 629 } 605 630 606 631 func (t *consensusStore) AuthoritativeImportProgress(tx transaction.Read) (uint64, error) { 607 607 - progBytes, err := tx.Tree().Get([]byte("aImportProgress")) 632 632 + progBytes, err := tx.Tree().Get([]byte(TreeAuthoritativeImportProgressKey)) 608 633 if err != nil { 609 634 return 0, stacktrace.Propagate(err, "") 610 635 } ··· 618 643 value := make([]byte, 8) 619 644 binary.BigEndian.PutUint64(value, nextCursor) 620 645 621 621 - _, err := tx.Tree().Set([]byte("aImportProgress"), value) 646 646 + _, err := tx.Tree().Set([]byte(TreeAuthoritativeImportProgressKey), value) 647 647 + return stacktrace.Propagate(err, "") 648 648 + } 649 649 + 650 650 + func marshalRangeChallengeCommitmentKey(validatorAddress []byte) []byte { 651 651 + key := make([]byte, TreeRangeChallengeKeyLength) 652 652 + key[0] = TreeRangeChallengeCommitmentKeyPrefix 653 653 + copy(key[1:], validatorAddress) 654 654 + return key 655 655 + } 656 656 + 657 657 + func marshalRangeChallengeCommitmentValue(fromHeight, toHeight, provenHeight, includedOnHeight uint64, treeRoot []byte) []byte { 658 658 + value := make([]byte, 8+8+8+32) 659 659 + binary.BigEndian.PutUint64(value, fromHeight) 660 660 + binary.BigEndian.PutUint64(value[8:], toHeight) 661 661 + binary.BigEndian.PutUint64(value[16:], provenHeight) 662 662 + binary.BigEndian.PutUint64(value[24:], includedOnHeight) 663 663 + copy(value[32:], treeRoot[0:24]) 664 664 + return value 665 665 + } 666 666 + 667 667 + func unmarshalRangeChallengeCommitmentValue(value []byte) (fromHeight, toHeight, provenHeight, includedOnHeight uint64, treeRoot []byte) { 668 668 + fromHeight = binary.BigEndian.Uint64(value) 669 669 + toHeight = binary.BigEndian.Uint64(value[8:]) 670 670 + provenHeight = binary.BigEndian.Uint64(value[16:]) 671 671 + includedOnHeight = binary.BigEndian.Uint64(value[24:]) 672 672 + treeRoot = slices.Clone(value[32:]) 673 673 + return 674 674 + } 675 675 + 676 676 + // ValidatorRangeChallengeCommitment implements [ConsensusStore]. 677 677 + func (t *consensusStore) ValidatorRangeChallengeCommitment(tx transaction.Read, validatorAddress []byte) (fromHeight, toHeight, provenHeight, includedOnHeight uint64, treeRoot []byte, err error) { 678 678 + key := marshalRangeChallengeCommitmentKey(validatorAddress) 679 679 + value, err := tx.Tree().Get(key) 680 680 + if err != nil { 681 681 + return 0, 0, 0, 0, nil, stacktrace.Propagate(err, "") 682 682 + } 683 683 + if value == nil { 684 684 + return 0, 0, 0, 0, nil, stacktrace.Propagate(ErrNoActiveChallengeCommitment, "") 685 685 + } 686 686 + fromHeight, toHeight, provenHeight, includedOnHeight, treeRoot = unmarshalRangeChallengeCommitmentValue(value) 687 687 + return 688 688 + } 689 689 + 690 690 + // SetValidatorRangeChallengeCommitment implements [ConsensusStore]. 691 691 + func (t *consensusStore) SetValidatorRangeChallengeCommitment(tx transaction.Write, validatorAddress []byte, fromHeight, toHeight, provenHeight, includedOnHeight uint64, treeRoot []byte) error { 692 692 + key := marshalRangeChallengeCommitmentKey(validatorAddress) 693 693 + value := marshalRangeChallengeCommitmentValue(fromHeight, toHeight, provenHeight, includedOnHeight, treeRoot) 694 694 + // this may overwrite sometimes (e.g. if a previous commitment has expired and the validator needs to submit a new one) 695 695 + _, err := tx.Tree().Set(key, value) 696 696 + return stacktrace.Propagate(err, "") 697 697 + } 698 698 + 699 699 + // ClearValidatorRangeChallengeCommitment implements [ConsensusStore]. 700 700 + func (t *consensusStore) ClearValidatorRangeChallengeCommitment(tx transaction.Write, validatorAddress []byte) error { 701 701 + _, removed, err := tx.Tree().Remove(marshalRangeChallengeCommitmentKey(validatorAddress)) 702 702 + if err != nil { 703 703 + return stacktrace.Propagate(err, "") 704 704 + } 705 705 + if !removed { 706 706 + // we are only expecting to call this after completing a range challenge, so we're expecting that the key would still exist 707 707 + // (we would have needed it to validate the challenge completion transaction) 708 708 + return stacktrace.NewError("validator did not have a range challenge commitment") 709 709 + } 710 710 + return nil 711 711 + } 712 712 + 713 713 + func marshalRangeChallengeCompletionKey(validatorAddress []byte) []byte { 714 714 + key := make([]byte, TreeChallengeCompletionKeyLength) 715 715 + key[0] = TreeChallengeCompletionKeyPrefix 716 716 + copy(key[1:], validatorAddress) 717 717 + return key 718 718 + } 719 719 + 720 720 + // ValidatorRangeChallengeCompletion implements [ConsensusStore]. 721 721 + func (t *consensusStore) ValidatorRangeChallengeCompletion(tx transaction.Read, validatorAddress []byte) (uint64, error) { 722 722 + key := marshalRangeChallengeCompletionKey(validatorAddress) 723 723 + value, err := tx.Tree().Get(key) 724 724 + if err != nil { 725 725 + return 0, stacktrace.Propagate(err, "") 726 726 + } 727 727 + if value == nil { 728 728 + return 0, stacktrace.Propagate(ErrNoRecentChallengeCompletion, "") 729 729 + } 730 730 + return binary.BigEndian.Uint64(value), nil 731 731 + } 732 732 + 733 733 + // SetValidatorRangeChallengeCompletion implements [ConsensusStore]. 734 734 + func (t *consensusStore) SetValidatorRangeChallengeCompletion(tx transaction.Write, validatorAddress []byte, completedToHeight uint64) error { 735 735 + key := marshalRangeChallengeCompletionKey(validatorAddress) 736 736 + value := binary.BigEndian.AppendUint64(nil, completedToHeight) 737 737 + _, err := tx.Tree().Set(key, value) 622 738 return stacktrace.Propagate(err, "") 623 739 } 624 740 625 741 func marshalBlockChallengeProofKey(block uint64) []byte { 626 626 - key := make([]byte, 1+8) 627 627 - key[0] = 'c' 742 742 + key := make([]byte, IndexBlockChallengeKeyLength) 743 743 + key[0] = IndexBlockChallengeKeyPrefix 628 744 629 745 binary.BigEndian.PutUint64(key[1:], block) 630 746

+1

transaction/iavl_adapter.go

··· 17 17 type UnifiedTree interface { 18 18 ReadTree 19 19 Set(key, value []byte) (bool, error) 20 20 + Remove(key []byte) ([]byte, bool, error) 20 21 } 21 22 22 23 type immutableToReadOnlyTree struct {

+12

types/tx.go

··· 1 1 + package types 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + 6 6 + ctypes "github.com/cometbft/cometbft/rpc/core/types" 7 7 + "github.com/cometbft/cometbft/types" 8 8 + ) 9 9 + 10 10 + type MempoolSubmitter interface { 11 11 + BroadcastTxCommit(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) 12 12 + }