+12 -12

abciapp/app.go

··· 13 13 "github.com/cometbft/cometbft/privval" 14 14 bftstore "github.com/cometbft/cometbft/store" 15 15 "github.com/cosmos/iavl" 16 16 + "github.com/gbl08ma/stacktrace" 16 17 "github.com/klauspost/compress/zstd" 17 17 - "github.com/palantir/stacktrace" 18 18 "github.com/samber/lo" 19 19 "tangled.org/gbl08ma.com/didplcbft/dbmtoiavldb" 20 20 "tangled.org/gbl08ma.com/didplcbft/dbmtoiavldb/zstddict" ··· 74 74 if snapshotDirectory != "" { 75 75 err = os.MkdirAll(snapshotDirectory, os.FileMode(0755)) 76 76 if err != nil { 77 77 - return nil, nil, nil, func() {}, stacktrace.Propagate(err, "") 77 77 + return nil, nil, nil, func() {}, stacktrace.Propagate(err) 78 78 } 79 79 } 80 80 ··· 96 96 97 97 d.txFactory, err = transaction.NewFactory(tree, indexDB, store.Consensus.CountOperations, store.NewDIDBloomFilterStore(d.logger, didBloomFilterPath)) 98 98 if err != nil { 99 99 - return nil, nil, nil, cancelRunnerContext, stacktrace.Propagate(err, "") 99 99 + return nil, nil, nil, cancelRunnerContext, stacktrace.Propagate(err) 100 100 } 101 101 102 102 d.fullyClearApplicationData = func() error { ··· 104 104 // and CometBFT only calls one ABCI method at a time 105 105 err := d.tree.Close() 106 106 if err != nil { 107 107 - return stacktrace.Propagate(err, "") 107 107 + return stacktrace.Propagate(err) 108 108 } 109 109 110 110 clearData() ··· 113 113 114 114 d.txFactory, err = transaction.NewFactory(tree, indexDB, store.Consensus.CountOperations, store.NewDIDBloomFilterStore(d.logger, didBloomFilterPath)) 115 115 if err != nil { 116 116 - return stacktrace.Propagate(err, "") 116 116 + return stacktrace.Propagate(err) 117 117 } 118 118 return nil 119 119 } ··· 133 133 st := time.Now() 134 134 err := d.txFactory.SaveDIDBloomFilter() 135 135 if err != nil { 136 136 - d.logger.Error("failed to save bloom filter", "error", stacktrace.Propagate(err, "")) 136 136 + d.logger.Error("failed to save bloom filter", "error", stacktrace.Propagate(err)) 137 137 } 138 138 d.logger.Debug("saved bloom filter", "took", time.Since(st)) 139 139 } ··· 152 152 if treeVersion > int64(lastSnapshotVersion+10000) { 153 153 err = d.createSnapshot(treeVersion, filepath.Join(snapshotDirectory, "snapshot.tmp")) 154 154 if err != nil { 155 155 - fmt.Println("FAILED TO TAKE SNAPSHOT", stacktrace.Propagate(err, "")) 155 155 + fmt.Println("FAILED TO TAKE SNAPSHOT", stacktrace.Propagate(err)) 156 156 } 157 157 fmt.Println("TOOK SNAPSHOT OF VERSION", treeVersion) 158 158 lastSnapshotVersion = treeVersion ··· 163 163 164 164 /*err = d.createSnapshot(tree.Version(), filepath.Join(snapshotDirectory, "snapshot.tmp")) 165 165 if err != nil { 166 166 - return nil, nil, func() {}, stacktrace.Propagate(err, "") 166 166 + return nil, nil, func() {}, stacktrace.Propagate(err) 167 167 }*/ 168 168 169 169 /* 170 170 tree2 := iavl.NewMutableTree(dbm.NewMemDB(), 2048, false, iavl.NewNopLogger()) 171 171 importer, err := tree2.Import(tree.Version()) 172 172 if err != nil { 173 173 - return nil, nil, func() {}, stacktrace.Propagate(err, "") 173 173 + return nil, nil, func() {}, stacktrace.Propagate(err) 174 174 } 175 175 cimporter := iavl.NewCompressImporter(importer) 176 176 ··· 178 178 for _, node := range nodes { 179 179 err := cimporter.Add(&node) 180 180 if err != nil { 181 181 - return nil, nil, func() {}, stacktrace.Propagate(err, "") 181 181 + return nil, nil, func() {}, stacktrace.Propagate(err) 182 182 } 183 183 } 184 184 err = importer.Commit() 185 185 if err != nil { 186 186 - return nil, nil, func() {}, stacktrace.Propagate(err, "") 186 186 + return nil, nil, func() {}, stacktrace.Propagate(err) 187 187 } 188 188 189 189 fmt.Println("Took", time.Since(st), "to import", len(nodes), "nodes") ··· 216 216 var err error 217 217 d.blockChallengeCoordinator, err = newBlockChallengeCoordinator(d.runnerContext, d.logger, d.txFactory, blockStore, d.validatorPubKey) 218 218 if err != nil { 219 219 - return stacktrace.Propagate(err, "") 219 219 + return stacktrace.Propagate(err) 220 220 } 221 221 222 222 return nil

+23 -23

abciapp/block_challenge.go

··· 19 19 "github.com/consensys/gnark/constraint" 20 20 "github.com/consensys/gnark/frontend" 21 21 gnarklogger "github.com/consensys/gnark/logger" 22 22 - "github.com/palantir/stacktrace" 22 22 + "github.com/gbl08ma/stacktrace" 23 23 "github.com/rs/zerolog" 24 24 "github.com/samber/lo" 25 25 "resenje.org/singleflight" ··· 97 97 98 98 operationData, lastCommitHash, err := c.blockChallengeOperationDataForHeight(tx, height) 99 99 if err != nil { 100 100 - return zeroValue, stacktrace.Propagate(err, "") 100 100 + return zeroValue, stacktrace.Propagate(err) 101 101 } 102 102 103 103 sharedPart := buildBlockChallengeCircuitAssignmentShared(lastCommitHash, [1550]byte(operationData)) ··· 107 107 }, nil 108 108 }).Build() 109 109 if err != nil { 110 110 - return nil, stacktrace.Propagate(err, "") 110 110 + return nil, stacktrace.Propagate(err) 111 111 } 112 112 113 113 return c, nil ··· 129 129 go func() { 130 130 _, err := c.loadOrComputeBlockChallengeProof(c.runnerContext, height) 131 131 if err != nil { 132 132 - c.logger.Error("failed to compute block challenge", "height", height, "error", stacktrace.Propagate(err, "")) 132 132 + c.logger.Error("failed to compute block challenge", "height", height, "error", stacktrace.Propagate(err)) 133 133 } 134 134 }() 135 135 } ··· 148 148 149 149 proof, err := store.Consensus.BlockChallengeProof(tx, uint64(height)) 150 150 if err != nil { 151 151 - return nil, stacktrace.Propagate(err, "") 151 151 + return nil, stacktrace.Propagate(err) 152 152 } 153 153 if proof == nil { 154 154 st := time.Now() 155 155 // compute and store 156 156 proof, err = c.computeBlockChallengeProof(tx, height) 157 157 if err != nil { 158 158 - return nil, stacktrace.Propagate(err, "") 158 158 + return nil, stacktrace.Propagate(err) 159 159 } 160 160 161 161 wtx, err := tx.UpgradeForIndexOnly() 162 162 if err != nil { 163 163 - return nil, stacktrace.Propagate(err, "") 163 163 + return nil, stacktrace.Propagate(err) 164 164 } 165 165 defer wtx.Rollback() 166 166 167 167 err = store.Consensus.StoreBlockChallengeProof(wtx, uint64(height), proof) 168 168 if err != nil { 169 169 - return nil, stacktrace.Propagate(err, "") 169 169 + return nil, stacktrace.Propagate(err) 170 170 } 171 171 172 172 err = wtx.Commit() 173 173 if err != nil { 174 174 - return nil, stacktrace.Propagate(err, "") 174 174 + return nil, stacktrace.Propagate(err) 175 175 } 176 176 177 177 c.logger.Debug("computed and stored block challenge", "height", height, "took", time.Since(st)) 178 178 } 179 179 return proof, nil 180 180 }) 181 181 - return proof, stacktrace.Propagate(err, "") 181 181 + return proof, stacktrace.Propagate(err) 182 182 } 183 183 184 184 func (c *blockChallengeCoordinator) computeBlockChallengeProof(tx transaction.Read, height int64) ([]byte, error) { 185 185 witness, err := c.buildPrivateChallengeWitnessForHeight(tx, height) 186 186 if err != nil { 187 187 - return nil, stacktrace.Propagate(err, "") 187 187 + return nil, stacktrace.Propagate(err) 188 188 } 189 189 proof, err := groth16.Prove(blockChallengeConstraintSystem, blockChallengeProvingKey, witness) 190 190 if err != nil { 191 191 - return nil, stacktrace.Propagate(err, "") 191 191 + return nil, stacktrace.Propagate(err) 192 192 } 193 193 194 194 buf := new(bytes.Buffer) 195 195 196 196 _, err = proof.WriteTo(buf) 197 197 if err != nil { 198 198 - return nil, stacktrace.Propagate(err, "") 198 198 + return nil, stacktrace.Propagate(err) 199 199 } 200 200 201 201 return buf.Bytes(), nil ··· 207 207 // this is because operations can change over time (nullification) and also the returned data for the highest operation indexes will be different 208 208 tx, err := c.txFactory.ReadHeight(time.Time{}, height-1) 209 209 if err != nil { 210 210 - return false, stacktrace.Propagate(err, "") 210 210 + return false, stacktrace.Propagate(err) 211 211 } 212 212 213 213 sharedPart, err := c.fetchOrBuildBlockChallengeCircuitAssignmentShared(tx, height) 214 214 if err != nil { 215 215 - return false, stacktrace.Propagate(err, "") 215 215 + return false, stacktrace.Propagate(err) 216 216 } 217 217 218 218 assignment := buildBlockChallengeCircuitAssignmentFull(sharedPart, validatorAddress) 219 219 220 220 witness, err := frontend.NewWitness(assignment, bn254.ID.ScalarField()) 221 221 if err != nil { 222 222 - return false, stacktrace.Propagate(err, "") 222 222 + return false, stacktrace.Propagate(err) 223 223 } 224 224 225 225 publicWitness, err := witness.Public() 226 226 if err != nil { 227 227 - return false, stacktrace.Propagate(err, "") 227 227 + return false, stacktrace.Propagate(err) 228 228 } 229 229 230 230 proof := groth16.NewProof(bn254.ID) 231 231 232 232 _, err = proof.ReadFrom(bytes.NewBuffer(proofBytes)) 233 233 if err != nil { 234 234 - return false, stacktrace.Propagate(err, "") 234 234 + return false, stacktrace.Propagate(err) 235 235 } 236 236 237 237 err = groth16.Verify(proof, blockChallengeVerifyingKey, publicWitness) ··· 241 241 func (c *blockChallengeCoordinator) buildPrivateChallengeWitnessForHeight(tx transaction.Read, height int64) (witness.Witness, error) { 242 242 sharedPart, err := c.fetchOrBuildBlockChallengeCircuitAssignmentShared(tx, height) 243 243 if err != nil { 244 244 - return nil, stacktrace.Propagate(err, "") 244 244 + return nil, stacktrace.Propagate(err) 245 245 } 246 246 247 247 assignment := buildBlockChallengeCircuitAssignmentFull(sharedPart, c.validatorAddress) 248 248 249 249 witness, err := frontend.NewWitness(assignment, bn254.ID.ScalarField()) 250 250 - return witness, stacktrace.Propagate(err, "") 250 250 + return witness, stacktrace.Propagate(err) 251 251 } 252 252 253 253 func (c *blockChallengeCoordinator) blockChallengeOperationDataForHeight(tx transaction.Read, height int64) ([]byte, []byte, error) { ··· 264 264 265 265 highestOp, err := tx.CountOperations() 266 266 if err != nil { 267 267 - return nil, nil, stacktrace.Propagate(err, "") 267 267 + return nil, nil, stacktrace.Propagate(err) 268 268 } 269 269 270 270 initialOpDataLen := proof.OperationDataLength + int(lastCommitHash[0]) ··· 284 284 } 285 285 } 286 286 if err != nil { 287 287 - return nil, nil, stacktrace.Propagate(err, "") 287 287 + return nil, nil, stacktrace.Propagate(err) 288 288 } 289 289 } 290 290 ··· 294 294 func (c *blockChallengeCoordinator) fetchOrBuildBlockChallengeCircuitAssignmentShared(tx transaction.Read, height int64) (proof.BlockChallengeCircuit, error) { 295 295 ctx := context.WithValue(c.runnerContext, contextTxKey{}, tx) 296 296 v, err := c.sharedWitnessDataCache.Get(ctx, height) 297 297 - return v, stacktrace.Propagate(err, "") 297 297 + return v, stacktrace.Propagate(err) 298 298 } 299 299 300 300 func buildBlockChallengeCircuitAssignmentShared(lastCommitHash []byte, data [1550]byte) proof.BlockChallengeCircuit {

+11 -11

abciapp/execution.go

··· 8 8 "time" 9 9 10 10 abcitypes "github.com/cometbft/cometbft/abci/types" 11 11 + "github.com/gbl08ma/stacktrace" 11 12 cbornode "github.com/ipfs/go-ipld-cbor" 12 12 - "github.com/palantir/stacktrace" 13 13 "github.com/samber/lo" 14 14 "github.com/samber/mo" 15 15 "tangled.org/gbl08ma.com/didplcbft/transaction" ··· 39 39 40 40 out, err := cbornode.DumpObject(tx) 41 41 if err != nil { 42 42 - return nil, stacktrace.Propagate(err, "") 42 42 + return nil, stacktrace.Propagate(err) 43 43 } 44 44 45 45 req.Txs = append(req.Txs, out) ··· 54 54 for _, tx := range toProcess { 55 55 result, err := processTx(ctx, deps, tx) 56 56 if err != nil { 57 57 - return nil, stacktrace.Propagate(err, "") 57 57 + return nil, stacktrace.Propagate(err) 58 58 } 59 59 60 60 if result.Code == 0 { ··· 81 81 maybeTx, err := d.maybeCreateAuthoritativeImportTx(ctx, deps.getAuthoritativeOperationsFetcher) 82 82 if err != nil { 83 83 // TODO don't fail absolutely silently always, we should at least check what the error is 84 84 - d.logger.Error("failed to create authoritative import transaction", "error", stacktrace.Propagate(err, "")) 84 84 + d.logger.Error("failed to create authoritative import transaction", "error", stacktrace.Propagate(err)) 85 85 } 86 86 87 87 if err == nil && len(maybeTx) != 0 { ··· 94 94 // (we trust that running the import will succeed, so just do bare minimum checks here) 95 95 result, err := processTx(ctx, d.transactionProcessorDependenciesForOngoingProcessing(false, req.Time), maybeTx) 96 96 if err != nil { 97 97 - return nil, stacktrace.Propagate(err, "") 97 97 + return nil, stacktrace.Propagate(err) 98 98 } 99 99 if result.Code == 0 { 100 100 acceptedTx = append(acceptedTx, maybeTx) ··· 137 137 for i, tx := range req.Txs { 138 138 result, action, processor, err := beginProcessTx(tx) 139 139 if err != nil { 140 140 - return nil, stacktrace.Propagate(err, "") 140 140 + return nil, stacktrace.Propagate(err) 141 141 } 142 142 if result.Code == 0 { 143 143 if action == TransactionActionAuthoritativeImport && i != len(req.Txs)-1 { ··· 147 147 148 148 result, err = finishProcessTx(ctx, deps, processor, tx) 149 149 if err != nil { 150 150 - return nil, stacktrace.Propagate(err, "") 150 150 + return nil, stacktrace.Propagate(err) 151 151 } 152 152 } 153 153 ··· 172 172 173 173 proof, err := d.blockChallengeCoordinator.loadOrComputeBlockChallengeProof(ctx, req.Height) 174 174 if err != nil { 175 175 - return nil, stacktrace.Propagate(err, "") 175 175 + return nil, stacktrace.Propagate(err) 176 176 } 177 177 return &abcitypes.ResponseExtendVote{ 178 178 VoteExtension: proof, ··· 192 192 193 193 proofOK, err := d.blockChallengeCoordinator.verifyBlockChallengeProof(req.Height, req.ValidatorAddress, req.VoteExtension) 194 194 if err != nil { 195 195 - return nil, stacktrace.Propagate(err, "") 195 195 + return nil, stacktrace.Propagate(err) 196 196 } 197 197 198 198 return &abcitypes.ResponseVerifyVoteExtension{ ··· 223 223 var err error 224 224 txResults[i], err = processTx(ctx, d.transactionProcessorDependenciesForOngoingProcessing(true, req.Time), tx) 225 225 if err != nil { 226 226 - return nil, stacktrace.Propagate(err, "") 226 226 + return nil, stacktrace.Propagate(err) 227 227 } 228 228 } 229 229 ··· 247 247 248 248 err := d.ongoingWrite.Commit() 249 249 if err != nil { 250 250 - return nil, stacktrace.Propagate(err, "") 250 250 + return nil, stacktrace.Propagate(err) 251 251 } 252 252 253 253 for _, r := range d.lastProcessedProposalExecTxResults {

+20 -20

abciapp/import.go

··· 19 19 "github.com/coder/websocket/wsjson" 20 20 cmtlog "github.com/cometbft/cometbft/libs/log" 21 21 "github.com/did-method-plc/go-didplc" 22 22 + "github.com/gbl08ma/stacktrace" 22 23 "github.com/ipfs/go-cid" 23 24 cbornode "github.com/ipfs/go-ipld-cbor" 24 24 - "github.com/palantir/stacktrace" 25 25 "tangled.org/gbl08ma.com/didplcbft/store" 26 26 ) 27 27 ··· 103 103 url, err := url.Parse(a.plcURL) 104 104 if err != nil { 105 105 // this really shouldn't happen 106 106 - a.logger.Error("authoritative operations fetcher failed to parse known good PLC URL", "error", stacktrace.Propagate(err, "")) 106 106 + a.logger.Error("authoritative operations fetcher failed to parse known good PLC URL", "error", stacktrace.Propagate(err)) 107 107 return 108 108 } 109 109 ··· 121 121 }) 122 122 if err != nil { 123 123 a.logger.Error("authoritative operations fetcher failed to dial websocket", 124 124 - "error", stacktrace.Propagate(err, ""), 124 124 + "error", stacktrace.Propagate(err), 125 125 "url", url.String(), 126 126 ) 127 127 return ··· 156 156 return 157 157 } 158 158 159 159 - a.logger.Error("authoritative operations fetcher failed to read from websocket", "error", stacktrace.Propagate(err, "")) 159 159 + a.logger.Error("authoritative operations fetcher failed to read from websocket", "error", stacktrace.Propagate(err)) 160 160 return 161 161 } 162 162 ··· 181 181 } 182 182 reachedEnd, err := a.fetchInMutex(ctx, a.highestFetchedSeq, OpsPerEagerFetch) 183 183 if err != nil { 184 184 - a.logger.Error("authoritative operations fetcher failed eager fetch", "error", stacktrace.Propagate(err, "")) 184 184 + a.logger.Error("authoritative operations fetcher failed eager fetch", "error", stacktrace.Propagate(err)) 185 185 } 186 186 187 187 if a.highestFetchedSeq > a.importProgress { ··· 214 214 func (a *authoritativeOperationsFetcher) fetchInMutex(ctx context.Context, after, count uint64) (bool, error) { 215 215 entries, _, err := fetchExportedBatchFromAuthoritativeSource(ctx, a.client, a.plcURL, after, count) 216 216 if err != nil { 217 217 - return false, stacktrace.Propagate(err, "") 217 217 + return false, stacktrace.Propagate(err) 218 218 } 219 219 220 220 for _, entry := range entries { ··· 241 241 242 242 re, err := a.fetchInMutex(ctx, after+i, count) 243 243 if err != nil { 244 244 - return nil, stacktrace.Propagate(err, "") 244 244 + return nil, stacktrace.Propagate(err) 245 245 } 246 246 247 247 reachedEnd = reachedEnd || re ··· 263 263 func fetchExportedBatchFromAuthoritativeSource(ctx context.Context, client *http.Client, plcURL string, startAt, maxCount uint64) ([]logEntryWithSeq, uint64, error) { 264 264 baseURL, err := url.JoinPath(plcURL, "/export") 265 265 if err != nil { 266 266 - return nil, 0, stacktrace.Propagate(err, "") 266 266 + return nil, 0, stacktrace.Propagate(err) 267 267 } 268 268 269 269 entries := make([]logEntryWithSeq, 0, maxCount) 270 270 for { 271 271 req, err := http.NewRequestWithContext(ctx, "GET", baseURL, nil) 272 272 if err != nil { 273 273 - return nil, 0, stacktrace.Propagate(err, "") 273 273 + return nil, 0, stacktrace.Propagate(err) 274 274 } 275 275 276 276 req.Header.Set("User-Agent", SoftwareUserAgent) ··· 284 284 285 285 resp, err := client.Do(req) 286 286 if err != nil { 287 287 - return nil, 0, stacktrace.Propagate(err, "") 287 287 + return nil, 0, stacktrace.Propagate(err) 288 288 } 289 289 defer resp.Body.Close() 290 290 ··· 298 298 for s.Scan() && len(entries) < int(maxCount) { 299 299 var entry logEntryWithSeq 300 300 if err := json.Unmarshal(s.Bytes(), &entry); err != nil { 301 301 - return nil, 0, stacktrace.Propagate(err, "") 301 301 + return nil, 0, stacktrace.Propagate(err) 302 302 } 303 303 entries = append(entries, entry) 304 304 numEntriesThisResponse++ 305 305 startAt = entry.Seq 306 306 } 307 307 if s.Err() != nil { 308 308 - return nil, 0, stacktrace.Propagate(s.Err(), "") 308 308 + return nil, 0, stacktrace.Propagate(s.Err()) 309 309 } 310 310 311 311 if uint64(numEntriesThisResponse) < requestCount || len(entries) >= int(maxCount) { ··· 330 330 331 331 _, err = hash.Write(didBytes) 332 332 if err != nil { 333 333 - return nil, stacktrace.Propagate(err, "") 333 333 + return nil, stacktrace.Propagate(err) 334 334 } 335 335 336 336 // Write CID ··· 342 342 343 343 _, err = hash.Write(cid.Bytes()) 344 344 if err != nil { 345 345 - return nil, stacktrace.Propagate(err, "") 345 345 + return nil, stacktrace.Propagate(err) 346 346 } 347 347 348 348 // Write CreatedAt ··· 356 356 357 357 _, err = hash.Write(tsBytes) 358 358 if err != nil { 359 359 - return nil, stacktrace.Propagate(err, "") 359 359 + return nil, stacktrace.Propagate(err) 360 360 } 361 361 362 362 // Nullified can't be part of the hash as it can change on the authoritative source at any moment, ··· 372 372 373 373 plcURL, err := store.Consensus.AuthoritativePLC(readTx) 374 374 if err != nil { 375 375 - return nil, stacktrace.Propagate(err, "") 375 375 + return nil, stacktrace.Propagate(err) 376 376 } 377 377 378 378 if plcURL == "" { ··· 382 382 383 383 cursor, err := store.Consensus.AuthoritativeImportProgress(readTx) 384 384 if err != nil { 385 385 - return nil, stacktrace.Propagate(err, "") 385 385 + return nil, stacktrace.Propagate(err) 386 386 } 387 387 388 388 aoc := aocGetter(plcURL) 389 389 390 390 entries, err := aoc.get(ctx, cursor, OpsPerImportTx) 391 391 if err != nil { 392 392 - return nil, stacktrace.Propagate(err, "") 392 392 + return nil, stacktrace.Propagate(err) 393 393 } 394 394 395 395 if len(entries) == 0 { ··· 399 399 400 400 hashBytes, err := computeLogEntriesHash(entries) 401 401 if err != nil { 402 402 - return nil, stacktrace.Propagate(err, "") 402 402 + return nil, stacktrace.Propagate(err) 403 403 } 404 404 405 405 tx := Transaction[AuthoritativeImportArguments]{ ··· 414 414 415 415 out, err := cbornode.DumpObject(tx) 416 416 if err != nil { 417 417 - return nil, stacktrace.Propagate(err, "") 417 417 + return nil, stacktrace.Propagate(err) 418 418 } 419 419 return out, nil 420 420 }

+5 -5

abciapp/info.go

··· 11 11 "time" 12 12 13 13 abcitypes "github.com/cometbft/cometbft/abci/types" 14 14 - "github.com/palantir/stacktrace" 14 14 + "github.com/gbl08ma/stacktrace" 15 15 "github.com/ucarion/urlpath" 16 16 "tangled.org/gbl08ma.com/didplcbft/plc" 17 17 "tangled.org/gbl08ma.com/didplcbft/transaction" ··· 81 81 Info: "DID not available: " + did, 82 82 }, nil 83 83 default: 84 84 - return nil, stacktrace.Propagate(err, "") 84 84 + return nil, stacktrace.Propagate(err) 85 85 } 86 86 } 87 87 88 88 docJSON, err := json.Marshal(doc) 89 89 if err != nil { 90 90 - return nil, stacktrace.Propagate(err, "") 90 90 + return nil, stacktrace.Propagate(err) 91 91 } 92 92 93 93 return &abcitypes.ResponseQuery{ ··· 144 144 Info: "DID not available: " + did, 145 145 }, nil 146 146 default: 147 147 - return nil, stacktrace.Propagate(err, "") 147 147 + return nil, stacktrace.Propagate(err) 148 148 } 149 149 } 150 150 151 151 dataJSON, err := json.Marshal(&data) 152 152 if err != nil { 153 153 - return nil, stacktrace.Propagate(err, "") 153 153 + return nil, stacktrace.Propagate(err) 154 154 } 155 155 156 156 return &abcitypes.ResponseQuery{

+3 -3

abciapp/mempool.go

··· 4 4 "context" 5 5 6 6 abcitypes "github.com/cometbft/cometbft/abci/types" 7 7 - "github.com/palantir/stacktrace" 7 7 + "github.com/gbl08ma/stacktrace" 8 8 ) 9 9 10 10 // CheckTx implements [types.Application]. 11 11 func (d *DIDPLCApplication) CheckTx(ctx context.Context, req *abcitypes.RequestCheckTx) (*abcitypes.ResponseCheckTx, error) { 12 12 result, action, processor, err := beginProcessTx(req.Tx) 13 13 if err != nil { 14 14 - return nil, stacktrace.Propagate(err, "") 14 14 + return nil, stacktrace.Propagate(err) 15 15 } 16 16 if result.Code == 0 { 17 17 if action == TransactionActionAuthoritativeImport { ··· 24 24 25 25 result, err = finishProcessTx(ctx, d.transactionProcessorDependenciesForCommittedRead(), processor, req.Tx) 26 26 if err != nil { 27 27 - return nil, stacktrace.Propagate(err, "") 27 27 + return nil, stacktrace.Propagate(err) 28 28 } 29 29 } 30 30

+31 -31

abciapp/range_challenge.go

··· 20 20 "github.com/cosmos/iavl" 21 21 "github.com/cosmos/iavl/db" 22 22 ics23 "github.com/cosmos/ics23/go" 23 23 + "github.com/gbl08ma/stacktrace" 23 24 cbornode "github.com/ipfs/go-ipld-cbor" 24 24 - "github.com/palantir/stacktrace" 25 25 "github.com/samber/mo" 26 26 "tangled.org/gbl08ma.com/didplcbft/store" 27 27 "tangled.org/gbl08ma.com/didplcbft/transaction" ··· 86 86 var err error 87 87 c.treeCache, err = theine.NewBuilder[treeCacheKey, cachedTree](2).Loading(c.proofTreeLoader).Build() 88 88 if err != nil { 89 89 - return nil, stacktrace.Propagate(err, "") 89 89 + return nil, stacktrace.Propagate(err) 90 90 } 91 91 92 92 return c, nil ··· 101 101 c.wg.Go(func() { 102 102 err := c.newBlocksSubscriber() 103 103 if err != nil { 104 104 - c.logger.Error("blocks subscriber failed", "error", stacktrace.Propagate(err, "")) 104 104 + c.logger.Error("blocks subscriber failed", "error", stacktrace.Propagate(err)) 105 105 } 106 106 }) 107 107 c.wg.Go(func() { ··· 117 117 if err != nil { 118 118 // note: this is expected in certain circumstances, such as the proof for the toHeight block not being ready yet as the block was just finalized 119 119 // (and the block may have been finalized without our votes) 120 120 - c.logger.Error("range challenge block handler error", "error", stacktrace.Propagate(err, "")) 120 120 + c.logger.Error("range challenge block handler error", "error", stacktrace.Propagate(err)) 121 121 } 122 122 }() 123 123 } ··· 155 155 completion, err := store.Consensus.ValidatorRangeChallengeCompletion(tx, c.validatorAddress) 156 156 if err != nil { 157 157 if !errors.Is(err, store.ErrNoRecentChallengeCompletion) { 158 158 - return 0, stacktrace.Propagate(err, "") 158 158 + return 0, stacktrace.Propagate(err) 159 159 } 160 160 completion = 0 161 161 } ··· 166 166 break 167 167 } 168 168 if err != nil { 169 169 - return 0, stacktrace.Propagate(err, "") 169 169 + return 0, stacktrace.Propagate(err) 170 170 } 171 171 172 172 minProvable := max(minProvenBlock, int64(completion+1)) ··· 240 240 } 241 241 nextFromHeight, err := c.getOrFetchNextProofFromHeight(tx) 242 242 if err != nil { 243 243 - return stacktrace.Propagate(err, "") 243 243 + return stacktrace.Propagate(err) 244 244 } 245 245 246 246 if deleteOldProofs { 247 247 writeTx, err := tx.UpgradeForIndexOnly() 248 248 if err != nil { 249 249 - return stacktrace.Propagate(err, "") 249 249 + return stacktrace.Propagate(err) 250 250 } 251 251 defer writeTx.Rollback() 252 252 253 253 err = store.Consensus.DeleteBlockChallengeProofsBelowHeight(ctx, writeTx, uint64(nextFromHeight)) 254 254 if err != nil { 255 255 - return stacktrace.Propagate(err, "") 255 255 + return stacktrace.Propagate(err) 256 256 } 257 257 258 258 err = writeTx.Commit() 259 259 if err != nil { 260 260 - return stacktrace.Propagate(err, "") 260 260 + return stacktrace.Propagate(err) 261 261 } 262 262 } 263 263 264 264 shouldCommitToChallenge = nextFromHeight+CommitToChallengeTargetInterval-1 <= newBlockHeight 265 265 } else if err != nil { 266 266 - return stacktrace.Propagate(err, "") 266 266 + return stacktrace.Propagate(err) 267 267 } else { 268 268 commitmentBlockMeta := c.nodeBlockStore.LoadBlockMeta(int64(includedOnHeight)) 269 269 commitmentExpired := false ··· 285 285 c.logger.Info("Creating challenge completion transaction", "fromHeight", fromHeight, "toHeight", toHeight, "provenHeight", provenHeight, "includedOnHeight", includedOnHeight) 286 286 transactionBytes, err = c.createCompleteChallengeTx(ctx, tx, int64(fromHeight), int64(toHeight), int64(provenHeight), int64(includedOnHeight)) 287 287 if err != nil { 288 288 - return stacktrace.Propagate(err, "") 288 288 + return stacktrace.Propagate(err) 289 289 } 290 290 } else if shouldCommitToChallenge { 291 291 c.logger.Info("Creating challenge commitment transaction", "toHeight", toHeight) ··· 296 296 // shouldCommitToChallenge will be true again on the next block and we'll try again 297 297 return nil 298 298 } 299 299 - return stacktrace.Propagate(err, "") 299 299 + return stacktrace.Propagate(err) 300 300 } 301 301 } 302 302 ··· 308 308 c.logger.Debug("broadcasting range challenge transaction", "hash", txHashHex) 309 309 result, err := c.mempoolSubmitter.BroadcastTx(ctx, transactionBytes, true) 310 310 if err != nil { 311 311 - return stacktrace.Propagate(err, "") 311 311 + return stacktrace.Propagate(err) 312 312 } 313 313 if result.CheckTx.Code == 0 && shouldCompleteChallenge { 314 314 c.hasSubmittedChallengeCompletion = true ··· 321 321 func (c *RangeChallengeCoordinator) createCommitToChallengeTx(ctx context.Context, tx transaction.Read, toHeight int64) ([]byte, error) { 322 322 fromHeight, err := c.getOrFetchNextProofFromHeight(tx) 323 323 if err != nil { 324 324 - return nil, stacktrace.Propagate(err, "") 324 324 + return nil, stacktrace.Propagate(err) 325 325 } 326 326 327 327 rangeSize := toHeight - fromHeight + 1 ··· 335 335 336 336 pubKeyArg, err := MarshalPubKeyForArguments(c.validatorPubKey) 337 337 if err != nil { 338 338 - return nil, stacktrace.Propagate(err, "") 338 338 + return nil, stacktrace.Propagate(err) 339 339 } 340 340 341 341 toHeightBlockMeta := c.nodeBlockStore.LoadBlockMeta(toHeight) ··· 351 351 352 352 commitToRoot, membershipProof, err := c.computeRangeChallengeProof(ctx, tx, fromHeight, toHeight, proveHeight) 353 353 if err != nil { 354 354 - return nil, stacktrace.Propagate(err, "") 354 354 + return nil, stacktrace.Propagate(err) 355 355 } 356 356 357 357 proofBytes, err := membershipProof.Marshal() 358 358 if err != nil { 359 359 - return nil, stacktrace.Propagate(err, "") 359 359 + return nil, stacktrace.Propagate(err) 360 360 } 361 361 362 362 transaction := Transaction[CommitToChallengeArguments]{ ··· 372 372 373 373 transaction, err = SignTransaction(c.validatorPrivKey, transaction) 374 374 if err != nil { 375 375 - return nil, stacktrace.Propagate(err, "") 375 375 + return nil, stacktrace.Propagate(err) 376 376 } 377 377 378 378 out, err := cbornode.DumpObject(transaction) 379 379 if err != nil { 380 380 - return nil, stacktrace.Propagate(err, "") 380 380 + return nil, stacktrace.Propagate(err) 381 381 } 382 382 return out, nil 383 383 } ··· 392 392 393 393 _, membershipProof, err := c.computeRangeChallengeProof(ctx, tx, fromHeight, toHeight, proveHeight) 394 394 if err != nil { 395 395 - return nil, stacktrace.Propagate(err, "") 395 395 + return nil, stacktrace.Propagate(err) 396 396 } 397 397 398 398 proofBytes, err := membershipProof.Marshal() 399 399 if err != nil { 400 400 - return nil, stacktrace.Propagate(err, "") 400 400 + return nil, stacktrace.Propagate(err) 401 401 } 402 402 403 403 transaction := Transaction[CompleteChallengeArguments]{ ··· 410 410 411 411 out, err := cbornode.DumpObject(transaction) 412 412 if err != nil { 413 413 - return nil, stacktrace.Propagate(err, "") 413 413 + return nil, stacktrace.Propagate(err) 414 414 } 415 415 return out, nil 416 416 } ··· 422 422 endHeight: endHeight, 423 423 }) 424 424 if err != nil { 425 425 - return nil, nil, stacktrace.Propagate(err, "") 425 425 + return nil, nil, stacktrace.Propagate(err) 426 426 } 427 427 428 428 proofKey := binary.BigEndian.AppendUint64(nil, uint64(proveHeight)) 429 429 430 430 membershipProof, err := ct.tree.GetMembershipProof(proofKey) 431 431 if err != nil { 432 432 - return nil, nil, stacktrace.Propagate(err, "") 432 432 + return nil, nil, stacktrace.Propagate(err) 433 433 } 434 434 435 435 return ct.root, membershipProof, nil ··· 474 474 for proofHeight, proof := range store.Consensus.BlockChalengeProofsIterator(tx, uint64(max(cacheKey.startHeight-1, 0)), &err) { 475 475 select { 476 476 case <-ctx.Done(): 477 477 - return zeroValue, stacktrace.Propagate(ctx.Err(), "") 477 477 + return zeroValue, stacktrace.Propagate(ctx.Err()) 478 478 default: 479 479 } 480 480 ··· 484 484 485 485 _, err := tree.Set(binary.BigEndian.AppendUint64(nil, proofHeight), slices.Clone(proof)) 486 486 if err != nil { 487 487 - return zeroValue, stacktrace.Propagate(err, "") 487 487 + return zeroValue, stacktrace.Propagate(err) 488 488 } 489 489 } 490 490 if err != nil { 491 491 - return zeroValue, stacktrace.Propagate(err, "") 491 491 + return zeroValue, stacktrace.Propagate(err) 492 492 } 493 493 494 494 rootHash, treeVersion, err := tree.SaveVersion() 495 495 if err != nil { 496 496 - return zeroValue, stacktrace.Propagate(err, "") 496 496 + return zeroValue, stacktrace.Propagate(err) 497 497 } 498 498 499 499 immutableTree, err := tree.GetImmutable(treeVersion) 500 500 if err != nil { 501 501 - return zeroValue, stacktrace.Propagate(err, "") 501 501 + return zeroValue, stacktrace.Propagate(err) 502 502 } 503 503 504 504 if immutableTree.Size() != cacheKey.endHeight-cacheKey.startHeight+1 { 505 505 - return zeroValue, stacktrace.Propagate(errMissingProofs, "") 505 505 + return zeroValue, stacktrace.Propagate(errMissingProofs) 506 506 } 507 507 508 508 return theine.Loaded[cachedTree]{

+52 -52

abciapp/snapshots.go

··· 19 19 dbm "github.com/cometbft/cometbft-db" 20 20 abcitypes "github.com/cometbft/cometbft/abci/types" 21 21 "github.com/cosmos/iavl" 22 22 + "github.com/gbl08ma/stacktrace" 22 23 "github.com/klauspost/compress/zstd" 23 23 - "github.com/palantir/stacktrace" 24 24 "tangled.org/gbl08ma.com/didplcbft/store" 25 25 ) 26 26 ··· 31 31 func (d *DIDPLCApplication) ListSnapshots(context.Context, *abcitypes.RequestListSnapshots) (*abcitypes.ResponseListSnapshots, error) { 32 32 files, err := filepath.Glob(filepath.Join(d.snapshotDirectory, "*.snapshot")) 33 33 if err != nil { 34 34 - return nil, stacktrace.Propagate(err, "") 34 34 + return nil, stacktrace.Propagate(err) 35 35 } 36 36 37 37 snapshots := make([]*abcitypes.Snapshot, 0, len(files)) 38 38 for _, filename := range files { 39 39 s, err := readSnapshotMetadata(filename) 40 40 if err != nil { 41 41 - return nil, stacktrace.Propagate(err, "") 41 41 + return nil, stacktrace.Propagate(err) 42 42 } 43 43 44 44 snapshots = append(snapshots, s) ··· 201 201 if d.snapshotApplier != nil { 202 202 err := d.snapshotApplier.Abort() 203 203 if err != nil { 204 204 - return nil, stacktrace.Propagate(err, "") 204 204 + return nil, stacktrace.Propagate(err) 205 205 } 206 206 } 207 207 ··· 220 220 Result: abcitypes.ResponseOfferSnapshot_REJECT_SENDER, 221 221 }, nil 222 222 } 223 223 - return nil, stacktrace.Propagate(err, "") 223 223 + return nil, stacktrace.Propagate(err) 224 224 } 225 225 226 226 return &abcitypes.ResponseOfferSnapshot{ ··· 233 233 234 234 it, err := d.tree.GetImmutable(treeVersion) 235 235 if err != nil { 236 236 - return stacktrace.Propagate(err, "") 236 236 + return stacktrace.Propagate(err) 237 237 } 238 238 239 239 // Delete tempFilename if it exists to ensure a fresh file is created ··· 241 241 242 242 f, err := os.Create(tempFilename) 243 243 if err != nil { 244 244 - return stacktrace.Propagate(err, "") 244 244 + return stacktrace.Propagate(err) 245 245 } 246 246 defer f.Close() 247 247 248 248 err = writeSnapshot(f, d.indexDB, it) 249 249 if err != nil { 250 250 - return stacktrace.Propagate(err, "") 250 250 + return stacktrace.Propagate(err) 251 251 } 252 252 253 253 err = f.Sync() 254 254 if err != nil { 255 255 - return stacktrace.Propagate(err, "") 255 255 + return stacktrace.Propagate(err) 256 256 } 257 257 258 258 hf, err := os.Create(filepath.Join(d.snapshotDirectory, fmt.Sprintf("%020d.chunksums", treeVersion))) 259 259 if err != nil { 260 260 - return stacktrace.Propagate(err, "") 260 260 + return stacktrace.Propagate(err) 261 261 } 262 262 defer hf.Close() 263 263 264 264 err = writeChunkHashes(f, hf) 265 265 if err != nil { 266 266 - return stacktrace.Propagate(err, "") 266 266 + return stacktrace.Propagate(err) 267 267 } 268 268 269 269 err = hf.Sync() 270 270 if err != nil { 271 271 - return stacktrace.Propagate(err, "") 271 271 + return stacktrace.Propagate(err) 272 272 } 273 273 274 274 err = f.Close() 275 275 if err != nil { 276 276 - return stacktrace.Propagate(err, "") 276 276 + return stacktrace.Propagate(err) 277 277 } 278 278 279 279 os.Rename(tempFilename, filepath.Join(d.snapshotDirectory, fmt.Sprintf("%020d.snapshot", treeVersion))) ··· 289 289 // file magic and version 290 290 c, err := bw.Write([]byte("didplcbft-snapshot")) 291 291 if err != nil { 292 292 - return stacktrace.Propagate(err, "") 292 292 + return stacktrace.Propagate(err) 293 293 } 294 294 writtenUntilReservedFields += c 295 295 296 296 c, err = bw.Write([]byte{0, 0, 0, 0, 0, 2}) 297 297 if err != nil { 298 298 - return stacktrace.Propagate(err, "") 298 298 + return stacktrace.Propagate(err) 299 299 } 300 300 writtenUntilReservedFields += c 301 301 ··· 303 303 binary.BigEndian.PutUint64(b, uint64(it.Version())) 304 304 c, err = bw.Write(b) 305 305 if err != nil { 306 306 - return stacktrace.Propagate(err, "") 306 306 + return stacktrace.Propagate(err) 307 307 } 308 308 writtenUntilReservedFields += c 309 309 310 310 c, err = bw.Write(it.Hash()) 311 311 if err != nil { 312 312 - return stacktrace.Propagate(err, "") 312 312 + return stacktrace.Propagate(err) 313 313 } 314 314 writtenUntilReservedFields += c 315 315 ··· 321 321 b = make([]byte, sizeOfReservedFields) 322 322 _, err = bw.Write(b) 323 323 if err != nil { 324 324 - return stacktrace.Propagate(err, "") 324 324 + return stacktrace.Propagate(err) 325 325 } 326 326 327 327 zstdw, err := zstd.NewWriter(bw, zstd.WithEncoderLevel(zstd.SpeedBetterCompression)) 328 328 if err != nil { 329 329 - return stacktrace.Propagate(err, "") 329 329 + return stacktrace.Propagate(err) 330 330 } 331 331 332 332 numIndexEntries, err := exportIndexEntries(indexDB, it.Version(), zstdw) 333 333 if err != nil { 334 334 - return stacktrace.Propagate(err, "") 334 334 + return stacktrace.Propagate(err) 335 335 } 336 336 337 337 numNodes, err := exportNodes(it, zstdw) 338 338 if err != nil { 339 339 - return stacktrace.Propagate(err, "") 339 339 + return stacktrace.Propagate(err) 340 340 } 341 341 342 342 err = zstdw.Close() 343 343 if err != nil { 344 344 - return stacktrace.Propagate(err, "") 344 344 + return stacktrace.Propagate(err) 345 345 } 346 346 347 347 err = bw.Flush() 348 348 if err != nil { 349 349 - return stacktrace.Propagate(err, "") 349 349 + return stacktrace.Propagate(err) 350 350 } 351 351 352 352 // find total compressed section size 353 353 offset, err := writerSeeker.Seek(0, io.SeekCurrent) 354 354 if err != nil { 355 355 - return stacktrace.Propagate(err, "") 355 355 + return stacktrace.Propagate(err) 356 356 } 357 357 compressedSectionSize := offset - int64(writtenUntilReservedFields) - int64(sizeOfReservedFields) 358 358 ··· 360 360 361 361 offset, err = writerSeeker.Seek(int64(writtenUntilReservedFields), io.SeekStart) 362 362 if err != nil { 363 363 - return stacktrace.Propagate(err, "") 363 363 + return stacktrace.Propagate(err) 364 364 } 365 365 if offset != int64(writtenUntilReservedFields) { 366 366 return stacktrace.NewError("unexpected seek result") ··· 372 372 binary.BigEndian.PutUint64(b[16:], uint64(numNodes)) 373 373 _, err = writerSeeker.Write(b) 374 374 if err != nil { 375 375 - return stacktrace.Propagate(err, "") 375 375 + return stacktrace.Propagate(err) 376 376 } 377 377 378 378 return nil ··· 386 386 387 387 iterator, err := indexDB.Iterator(didLogKeyStart, didLogKeyEnd) 388 388 if err != nil { 389 389 - return 0, stacktrace.Propagate(err, "") 389 389 + return 0, stacktrace.Propagate(err) 390 390 } 391 391 defer iterator.Close() 392 392 ··· 403 403 404 404 _, err = w.Write(header) 405 405 if err != nil { 406 406 - return 0, stacktrace.Propagate(err, "") 406 406 + return 0, stacktrace.Propagate(err) 407 407 } 408 408 409 409 _, err = w.Write(key) 410 410 if err != nil { 411 411 - return 0, stacktrace.Propagate(err, "") 411 411 + return 0, stacktrace.Propagate(err) 412 412 } 413 413 414 414 _, err = w.Write(value) 415 415 if err != nil { 416 416 - return 0, stacktrace.Propagate(err, "") 416 416 + return 0, stacktrace.Propagate(err) 417 417 } 418 418 419 419 numEntries++ ··· 427 427 func exportNodes(it *iavl.ImmutableTree, w io.Writer) (int64, error) { 428 428 exporter, err := it.Export() 429 429 if err != nil { 430 430 - return 0, stacktrace.Propagate(err, "") 430 430 + return 0, stacktrace.Propagate(err) 431 431 } 432 432 defer exporter.Close() 433 433 cexporter := iavl.NewCompressExporter(exporter) ··· 446 446 break 447 447 } 448 448 if err != nil { 449 449 - return 0, stacktrace.Propagate(err, "") 449 449 + return 0, stacktrace.Propagate(err) 450 450 } 451 451 452 452 nodeHeaderBuffer[0] = byte(node.Height) ··· 468 468 469 469 _, err = w.Write(nodeHeaderBuffer) 470 470 if err != nil { 471 471 - return 0, stacktrace.Propagate(err, "") 471 471 + return 0, stacktrace.Propagate(err) 472 472 } 473 473 474 474 _, err = w.Write(node.Key) 475 475 if err != nil { 476 476 - return 0, stacktrace.Propagate(err, "") 476 476 + return 0, stacktrace.Propagate(err) 477 477 } 478 478 479 479 _, err = w.Write(node.Value) 480 480 if err != nil { 481 481 - return 0, stacktrace.Propagate(err, "") 481 481 + return 0, stacktrace.Propagate(err) 482 482 } 483 483 numNodes++ 484 484 } ··· 492 492 493 493 _, err := snapshotFile.Seek(0, io.SeekStart) 494 494 if err != nil { 495 495 - return stacktrace.Propagate(err, "") 495 495 + return stacktrace.Propagate(err) 496 496 } 497 497 498 498 buf := make([]byte, snapshotChunkSize) 499 499 for { 500 500 n, err := io.ReadFull(snapshotFile, buf) 501 501 if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF { 502 502 - return stacktrace.Propagate(err, "") 502 502 + return stacktrace.Propagate(err) 503 503 } 504 504 if n == 0 { 505 505 break ··· 508 508 hash := sha256.Sum256(buf[:n]) 509 509 c, err := w.Write(hash[:]) 510 510 if err != nil { 511 511 - return stacktrace.Propagate(err, "") 511 511 + return stacktrace.Propagate(err) 512 512 } 513 513 514 514 if c != snapshotChunkHashSize { ··· 551 551 552 552 func (d *DIDPLCApplication) beginApplyingSnapshot(treeVersion int64, expectedFinalHash []byte, expectedNumChunks int, chunksums []byte) (*snapshotApplier, error) { 553 553 if len(chunksums)%snapshotChunkHashSize != 0 || len(chunksums)/snapshotChunkHashSize != expectedNumChunks { 554 554 - return nil, stacktrace.Propagate(errInvalidMetadata, "") 554 554 + return nil, stacktrace.Propagate(errInvalidMetadata) 555 555 } 556 556 557 557 if !d.tree.IsEmpty() { 558 558 err := d.fullyClearApplicationData() 559 559 if err != nil { 560 560 - return nil, stacktrace.Propagate(err, "") 560 560 + return nil, stacktrace.Propagate(err) 561 561 } 562 562 } 563 563 564 564 importer, err := d.tree.Import(treeVersion) 565 565 if err != nil { 566 566 - return nil, stacktrace.Propagate(err, "") 566 566 + return nil, stacktrace.Propagate(err) 567 567 } 568 568 569 569 pipeReader, pipeWriter := io.Pipe() 570 570 571 571 zstdReader, err := zstd.NewReader(pipeReader) 572 572 if err != nil { 573 573 - return nil, stacktrace.Propagate(err, "") 573 573 + return nil, stacktrace.Propagate(err) 574 574 } 575 575 576 576 chunkHashes := make([][]byte, 0, expectedNumChunks) ··· 670 670 671 671 err := a.indexBatch.Write() 672 672 if err != nil { 673 673 - return stacktrace.Propagate(err, "") 673 673 + return stacktrace.Propagate(err) 674 674 } 675 675 676 676 err = a.importer.Commit() 677 677 if err != nil { 678 678 if strings.Contains(err.Error(), "invalid node structure") { 679 679 - return stacktrace.Propagate(errors.Join(errMalformedChunk, err), "") 679 679 + return stacktrace.Propagate(errors.Join(errMalformedChunk, err)) 680 680 } 681 681 - return stacktrace.Propagate(err, "") 681 681 + return stacktrace.Propagate(err) 682 682 } 683 683 684 684 a.closeCommons() 685 685 a.done = true 686 686 687 687 if !bytes.Equal(a.tree.Hash(), a.expectedFinalHash) { 688 688 - return stacktrace.Propagate(errTreeHashMismatch, "") 688 688 + return stacktrace.Propagate(errTreeHashMismatch) 689 689 } 690 690 } 691 691 ··· 788 788 func (a *snapshotApplier) Abort() error { 789 789 err := a.closeCommons() 790 790 if err != nil { 791 791 - return stacktrace.Propagate(err, "") 791 791 + return stacktrace.Propagate(err) 792 792 } 793 793 794 794 err = a.tree.DeleteVersionsFrom(0) 795 795 if err != nil { 796 796 - return stacktrace.Propagate(err, "") 796 796 + return stacktrace.Propagate(err) 797 797 } 798 798 799 799 return nil ··· 802 802 func (a *snapshotApplier) closeCommons() error { 803 803 err := a.zstdReader.Close() 804 804 if err != nil { 805 805 - return stacktrace.Propagate(err, "") 805 805 + return stacktrace.Propagate(err) 806 806 } 807 807 808 808 err = a.pipeReader.Close() 809 809 if err != nil { 810 810 - return stacktrace.Propagate(err, "") 810 810 + return stacktrace.Propagate(err) 811 811 } 812 812 813 813 err = a.pipeWriter.Close() 814 814 if err != nil { 815 815 - return stacktrace.Propagate(err, "") 815 815 + return stacktrace.Propagate(err) 816 816 } 817 817 818 818 err = a.indexBatch.Close() 819 819 if err != nil { 820 820 - return stacktrace.Propagate(err, "") 820 820 + return stacktrace.Propagate(err) 821 821 } 822 822 823 823 a.importerWg.Wait()

+10 -10

abciapp/tx.go

··· 10 10 "github.com/cometbft/cometbft/crypto/secp256k1" 11 11 bftstore "github.com/cometbft/cometbft/store" 12 12 cmttypes "github.com/cometbft/cometbft/types" 13 13 + "github.com/gbl08ma/stacktrace" 13 14 cbornode "github.com/ipfs/go-ipld-cbor" 14 14 - "github.com/palantir/stacktrace" 15 15 "github.com/samber/mo" 16 16 "tangled.org/gbl08ma.com/didplcbft/plc" 17 17 "tangled.org/gbl08ma.com/didplcbft/transaction" ··· 63 63 var t Transaction[ArgType] 64 64 err := cbornode.DecodeInto(txBytes, &t) 65 65 if err != nil { 66 66 - return Transaction[ArgType]{}, stacktrace.Propagate(err, "") 66 66 + return Transaction[ArgType]{}, stacktrace.Propagate(err) 67 67 } 68 68 69 69 var argType ArgType ··· 83 83 } 84 84 b, err := cbornode.DumpObject(v) 85 85 if err != nil { 86 86 - return nil, stacktrace.Propagate(err, "") 86 86 + return nil, stacktrace.Propagate(err) 87 87 } 88 88 return b, nil 89 89 } ··· 112 112 113 113 bytesToSign, err := cbornode.DumpObject(tx) 114 114 if err != nil { 115 115 - return zeroValue, stacktrace.Propagate(err, "") 115 115 + return zeroValue, stacktrace.Propagate(err) 116 116 } 117 117 118 118 tx.Signature, err = privKey.Sign(bytesToSign) 119 119 if err != nil { 120 120 - return zeroValue, stacktrace.Propagate(err, "") 120 120 + return zeroValue, stacktrace.Propagate(err) 121 121 } 122 122 123 123 return tx, nil ··· 129 129 130 130 bytesToSign, err := cbornode.DumpObject(tx) 131 131 if err != nil { 132 132 - return false, stacktrace.Propagate(err, "") 132 132 + return false, stacktrace.Propagate(err) 133 133 } 134 134 135 135 return publicKey.VerifySignature(bytesToSign, sig), nil ··· 141 141 142 142 bytesToSign, err := cbornode.DumpObject(tx) 143 143 if err != nil { 144 144 - return false, nil, stacktrace.Propagate(err, "") 144 144 + return false, nil, stacktrace.Propagate(err) 145 145 } 146 146 147 147 var pubKey crypto.PubKey ··· 238 238 239 239 func finishProcessTx(ctx context.Context, deps TransactionProcessorDependencies, processor TransactionProcessor, txBytes []byte) (*processResult, error) { 240 240 result, err := processor(ctx, deps, txBytes) 241 241 - return result, stacktrace.Propagate(err, "") 241 241 + return result, stacktrace.Propagate(err) 242 242 } 243 243 244 244 func processTx(ctx context.Context, deps TransactionProcessorDependencies, txBytes []byte) (*processResult, error) { 245 245 result, _, processor, err := beginProcessTx(txBytes) 246 246 if err != nil { 247 247 - return nil, stacktrace.Propagate(err, "") 247 247 + return nil, stacktrace.Propagate(err) 248 248 } 249 249 if result.Code != 0 { 250 250 return result, nil 251 251 } 252 252 253 253 result, err = finishProcessTx(ctx, deps, processor, txBytes) 254 254 - return result, stacktrace.Propagate(err, "") 254 254 + return result, stacktrace.Propagate(err) 255 255 }

+10 -10

abciapp/tx_challenge.go

··· 7 7 "time" 8 8 9 9 ics23 "github.com/cosmos/ics23/go" 10 10 + "github.com/gbl08ma/stacktrace" 10 11 cbornode "github.com/ipfs/go-ipld-cbor" 11 11 - "github.com/palantir/stacktrace" 12 12 "github.com/samber/lo" 13 13 "github.com/samber/mo" 14 14 "tangled.org/gbl08ma.com/didplcbft/store" ··· 67 67 68 68 verified, validatorPubKey, err := VerifyTransactionSignatureWithMarshalledPubKey(tx.Arguments.ValidatorPubKey, tx) 69 69 if err != nil { 70 70 - return nil, stacktrace.Propagate(err, "") 70 70 + return nil, stacktrace.Propagate(err) 71 71 } 72 72 73 73 if !verified { ··· 131 131 }, nil 132 132 } 133 133 } else if !errors.Is(err, store.ErrNoRecentChallengeCompletion) { 134 134 - return nil, stacktrace.Propagate(err, "") 134 134 + return nil, stacktrace.Propagate(err) 135 135 } 136 136 137 137 if len(tx.Arguments.Root) != 32 { ··· 169 169 170 170 blockProofValid, err := deps.blockChallengeCoordinator.verifyBlockChallengeProof(int64(proofHeight), validatorAddress, existenceProof.Value) 171 171 if err != nil { 172 172 - return nil, stacktrace.Propagate(err, "") 172 172 + return nil, stacktrace.Propagate(err) 173 173 } 174 174 if !blockProofValid { 175 175 return &processResult{ ··· 195 195 uint64(deps.workingHeight), 196 196 tx.Arguments.Root) 197 197 if err != nil { 198 198 - return nil, stacktrace.Propagate(err, "") 198 198 + return nil, stacktrace.Propagate(err) 199 199 } 200 200 } 201 201 ··· 244 244 Info: "validator is not committed to a challenge", 245 245 }, nil 246 246 } 247 247 - return nil, stacktrace.Propagate(err, "") 247 247 + return nil, stacktrace.Propagate(err) 248 248 } 249 249 250 250 if int64(includedOnHeight)+CompleteChallengeMaxAgeInBlocks < deps.workingHeight { ··· 300 300 301 301 blockProofValid, err := deps.blockChallengeCoordinator.verifyBlockChallengeProof(int64(proofHeight), tx.Arguments.Validator, existenceProof.Value) 302 302 if err != nil { 303 303 - return nil, stacktrace.Propagate(err, "") 303 303 + return nil, stacktrace.Propagate(err) 304 304 } 305 305 if !blockProofValid { 306 306 return &processResult{ ··· 319 319 if writeTx, ok := deps.writeTx.Get(); ok { 320 320 err = store.Consensus.ClearValidatorRangeChallengeCommitment(writeTx, tx.Arguments.Validator) 321 321 if err != nil { 322 322 - return nil, stacktrace.Propagate(err, "") 322 322 + return nil, stacktrace.Propagate(err) 323 323 } 324 324 325 325 err = store.Consensus.SetValidatorRangeChallengeCompletion(writeTx, tx.Arguments.Validator, toHeight) 326 326 if err != nil { 327 327 - return nil, stacktrace.Propagate(err, "") 327 327 + return nil, stacktrace.Propagate(err) 328 328 } 329 329 330 330 numProvenBlocks := toHeight - fromHeight + 1 ··· 332 332 333 333 err = store.Consensus.ChangeValidatorReputation(writeTx, tx.Arguments.Validator, int64(repGain)) 334 334 if err != nil { 335 335 - return nil, stacktrace.Propagate(err, "") 335 335 + return nil, stacktrace.Propagate(err) 336 336 } 337 337 } 338 338

+1 -1

abciapp/tx_create_plc_op.go

··· 5 5 "encoding/json" 6 6 7 7 "github.com/did-method-plc/go-didplc" 8 8 + "github.com/gbl08ma/stacktrace" 8 9 cbornode "github.com/ipfs/go-ipld-cbor" 9 9 - "github.com/palantir/stacktrace" 10 10 "tangled.org/gbl08ma.com/didplcbft/plc" 11 11 ) 12 12

+8 -8

abciapp/tx_import.go

··· 5 5 "encoding/hex" 6 6 "net/url" 7 7 8 8 + "github.com/gbl08ma/stacktrace" 8 9 cbornode "github.com/ipfs/go-ipld-cbor" 9 9 - "github.com/palantir/stacktrace" 10 10 "tangled.org/gbl08ma.com/didplcbft/store" 11 11 ) 12 12 ··· 56 56 if writeTx, ok := deps.writeTx.Get(); ok { 57 57 err = store.Consensus.SetAuthoritativePLC(writeTx, tx.Arguments.PLCURL) 58 58 if err != nil { 59 59 - return nil, stacktrace.Propagate(err, "") 59 59 + return nil, stacktrace.Propagate(err) 60 60 } 61 61 62 62 if tx.Arguments.RestartImport { 63 63 err = store.Consensus.SetAuthoritativeImportProgress(writeTx, 0) 64 64 if err != nil { 65 65 - return nil, stacktrace.Propagate(err, "") 65 65 + return nil, stacktrace.Propagate(err) 66 66 } 67 67 } 68 68 } ··· 104 104 105 105 expectedPlcUrl, err := store.Consensus.AuthoritativePLC(deps.readTx) 106 106 if err != nil { 107 107 - return nil, stacktrace.Propagate(err, "") 107 107 + return nil, stacktrace.Propagate(err) 108 108 } 109 109 110 110 if expectedPlcUrl != tx.Arguments.PLCURL { ··· 118 118 119 119 expectedCursor, err := store.Consensus.AuthoritativeImportProgress(deps.readTx) 120 120 if err != nil { 121 121 - return nil, stacktrace.Propagate(err, "") 121 121 + return nil, stacktrace.Propagate(err) 122 122 } 123 123 124 124 if expectedCursor != tx.Arguments.Cursor { ··· 152 152 153 153 expectedHashBytes, err := computeLogEntriesHash(operations) 154 154 if err != nil { 155 155 - return nil, stacktrace.Propagate(err, "") 155 155 + return nil, stacktrace.Propagate(err) 156 156 } 157 157 158 158 if hex.EncodeToString(expectedHashBytes) != tx.Arguments.Hash { ··· 171 171 for _, op := range operations { 172 172 err := deps.plc.ImportOperationFromAuthoritativeSource(ctx, writeTx, op.LogEntry) 173 173 if err != nil { 174 174 - return nil, stacktrace.Propagate(err, "") 174 174 + return nil, stacktrace.Propagate(err) 175 175 } 176 176 } 177 177 178 178 err = store.Consensus.SetAuthoritativeImportProgress(writeTx, newCursor) 179 179 if err != nil { 180 180 - return nil, stacktrace.Propagate(err, "") 180 180 + return nil, stacktrace.Propagate(err) 181 181 } 182 182 } 183 183

+5 -5

dbmtoiavldb/adapter.go

··· 6 6 "cosmossdk.io/core/store" 7 7 dbm "github.com/cometbft/cometbft-db" 8 8 iavldbm "github.com/cosmos/iavl/db" 9 9 + "github.com/gbl08ma/stacktrace" 9 10 "github.com/klauspost/compress/zstd" 10 10 - "github.com/palantir/stacktrace" 11 11 ) 12 12 13 13 type AdaptedDB struct { ··· 46 46 func (b *AdaptedDB) Get(key []byte) ([]byte, error) { 47 47 v, err := b.underlying.Get(key) 48 48 if err != nil { 49 49 - return nil, stacktrace.Propagate(err, "") 49 49 + return nil, stacktrace.Propagate(err) 50 50 } 51 51 v, err = decompressValue(b.zstdDecoder, v) 52 52 - return v, stacktrace.Propagate(err, "") 52 52 + return v, stacktrace.Propagate(err) 53 53 } 54 54 55 55 // Has implements [iavldbm.DB]. ··· 146 146 // Set implements [store.Batch]. 147 147 func (a *AdaptedBatch) Set(key []byte, value []byte) error { 148 148 v := compressValue(a.zstdEncoder, value) 149 149 - return stacktrace.Propagate(a.underlying.Set(key, v), "") 149 149 + return stacktrace.Propagate(a.underlying.Set(key, v)) 150 150 } 151 151 152 152 // Write implements [store.Batch]. ··· 186 186 // passing a nil output buffer to DecodeAll means it'll optimistically start by allocating len(value)*2 187 187 // but we observe compression ratios better than 50% frequently, so we allocate a slice ourselves with cap len(value)*3 188 188 value, err := decoder.DecodeAll(value[1:], make([]byte, 0, len(value)*3)) 189 189 - return value, stacktrace.Propagate(err, "") 189 189 + return value, stacktrace.Propagate(err) 190 190 } 191 191 192 192 // this is a simplified version of slices.Insert for prepending a single element to a slice, returning the modified slice

+1 -3

go.mod

··· 16 16 github.com/cosmos/ics23/go v0.10.0 17 17 github.com/dgraph-io/badger/v4 v4.9.0 18 18 github.com/did-method-plc/go-didplc v0.0.0-20251125183445-342320c327e2 19 19 + github.com/gbl08ma/stacktrace v0.1.0 19 20 github.com/google/uuid v1.6.0 20 21 github.com/ipfs/go-cid v0.4.1 21 22 github.com/ipfs/go-ipld-cbor v0.1.0 22 23 github.com/klauspost/compress v1.18.0 23 23 - github.com/palantir/stacktrace v0.0.0-20161112013806-78658fd2d177 24 24 github.com/polydawn/refmt v0.89.1-0.20221221234430-40501e09de1f 25 25 github.com/puzpuzpuz/xsync/v4 v4.2.0 26 26 github.com/rs/cors v1.11.1 ··· 140 140 gopkg.in/yaml.v3 v3.0.1 // indirect 141 141 lukechampine.com/blake3 v1.2.1 // indirect 142 142 ) 143 143 - 144 144 - replace github.com/palantir/stacktrace v0.0.0-20161112013806-78658fd2d177 => github.com/gsgalloway/stacktrace v0.0.0-20200507040314-ca3802f754c7

+2 -3

go.sum

··· 100 100 github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= 101 101 github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM= 102 102 github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ= 103 103 + github.com/gbl08ma/stacktrace v0.1.0 h1:Ti8acZjse/69roQuD1xaEOwR+7vqFQ7f5LhHOS073rk= 104 104 + github.com/gbl08ma/stacktrace v0.1.0/go.mod h1:U9NeV3Sx2sZj2CJtEsi/NBiQLGdzczJTPA7RgDTKZME= 103 105 github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= 104 106 github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= 105 107 github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= ··· 151 153 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= 152 154 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= 153 155 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= 154 154 - github.com/gsgalloway/stacktrace v0.0.0-20200507040314-ca3802f754c7 h1:hEyBOiA4Zv1nIstYO3VU4p/t/m5ikHZWnyQOgteoc+E= 155 155 - github.com/gsgalloway/stacktrace v0.0.0-20200507040314-ca3802f754c7/go.mod h1:AWPtRYnH+Coi03yskhmgZHPcZrv89PoxagXJr1TsFyc= 156 156 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= 157 157 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= 158 158 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= ··· 312 312 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= 313 313 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= 314 314 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= 315 315 - github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= 316 315 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= 317 316 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= 318 317 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=

+2 -5

httpapi/server.go

··· 18 18 19 19 "github.com/bluesky-social/indigo/atproto/atcrypto" 20 20 "github.com/did-method-plc/go-didplc" 21 21 + "github.com/gbl08ma/stacktrace" 21 22 cbornode "github.com/ipfs/go-ipld-cbor" 22 22 - "github.com/palantir/stacktrace" 23 23 "github.com/rs/cors" 24 24 "github.com/samber/lo" 25 25 ··· 132 132 func (s *Server) Stop() error { 133 133 ctx, cancel := context.WithTimeout(context.Background(), s.handlerTimeout) 134 134 defer cancel() 135 135 - if err := s.srv.Shutdown(ctx); err != nil { 136 136 - return stacktrace.Propagate(err, "") 137 137 - } 138 138 - return nil 135 135 + return stacktrace.Propagate(s.srv.Shutdown(ctx)) 139 136 } 140 137 141 138 func (s *Server) Wait() {

+16 -16

plc/impl.go

··· 5 5 6 6 "github.com/bluesky-social/indigo/atproto/syntax" 7 7 "github.com/did-method-plc/go-didplc" 8 8 - "github.com/palantir/stacktrace" 8 8 + "github.com/gbl08ma/stacktrace" 9 9 "github.com/samber/lo" 10 10 "github.com/samber/mo" 11 11 "tangled.org/gbl08ma.com/didplcbft/store" ··· 80 80 // looks like we already have the op we're trying to import. just need to update the timestamp 81 81 newCreatedAtDT, err := syntax.ParseDatetime(newEntry.CreatedAt) 82 82 if err != nil { 83 83 - return stacktrace.Propagate(err, "") 83 83 + return stacktrace.Propagate(err) 84 84 } 85 85 86 86 return stacktrace.Propagate( ··· 98 98 } 99 99 } 100 100 if iteratorErr != nil { 101 101 - return stacktrace.Propagate(iteratorErr, "") 101 101 + return stacktrace.Propagate(iteratorErr) 102 102 } 103 103 104 104 if !hasExistingOps { ··· 131 131 var iteratorErr error 132 132 for entry := range store.Consensus.AuditLogReverseIterator(ctx, tx, did, &iteratorErr) { 133 133 if entry.Operation.Tombstone != nil { 134 134 - return didplc.Doc{}, stacktrace.Propagate(ErrDIDGone, "") 134 134 + return didplc.Doc{}, stacktrace.Propagate(ErrDIDGone) 135 135 } 136 136 return entry.Operation.AsOperation().Doc(did) 137 137 } 138 138 if iteratorErr != nil { 139 139 - return didplc.Doc{}, stacktrace.Propagate(iteratorErr, "") 139 139 + return didplc.Doc{}, stacktrace.Propagate(iteratorErr) 140 140 } 141 141 142 142 - return didplc.Doc{}, stacktrace.Propagate(ErrDIDNotFound, "") 142 142 + return didplc.Doc{}, stacktrace.Propagate(ErrDIDNotFound) 143 143 } 144 144 145 145 func (plc *plcImpl) OperationLog(ctx context.Context, tx transaction.Read, did string) ([]didplc.OpEnum, error) { ··· 149 149 150 150 l, _, err := store.Consensus.AuditLog(ctx, tx, did, false) 151 151 if err != nil { 152 152 - return nil, stacktrace.Propagate(err, "") 152 152 + return nil, stacktrace.Propagate(err) 153 153 } 154 154 155 155 if len(l) == 0 { 156 156 - return nil, stacktrace.Propagate(ErrDIDNotFound, "") 156 156 + return nil, stacktrace.Propagate(ErrDIDNotFound) 157 157 } 158 158 159 159 l = lo.Filter(l, func(logEntry types.SequencedLogEntry, _ int) bool { ··· 171 171 // if tombstone -> returns log as normal 172 172 l, _, err := store.Consensus.AuditLog(ctx, tx, did, false) 173 173 if err != nil { 174 174 - return nil, stacktrace.Propagate(err, "") 174 174 + return nil, stacktrace.Propagate(err) 175 175 } 176 176 177 177 if len(l) == 0 { 178 178 - return nil, stacktrace.Propagate(ErrDIDNotFound, "") 178 178 + return nil, stacktrace.Propagate(ErrDIDNotFound) 179 179 } 180 180 181 181 return lo.Map(l, func(logEntry types.SequencedLogEntry, _ int) didplc.LogEntry { ··· 193 193 return entry.Operation, nil 194 194 } 195 195 if iteratorErr != nil { 196 196 - return didplc.OpEnum{}, stacktrace.Propagate(iteratorErr, "") 196 196 + return didplc.OpEnum{}, stacktrace.Propagate(iteratorErr) 197 197 } 198 198 199 199 - return didplc.OpEnum{}, stacktrace.Propagate(ErrDIDNotFound, "") 199 199 + return didplc.OpEnum{}, stacktrace.Propagate(ErrDIDNotFound) 200 200 } 201 201 202 202 func (plc *plcImpl) Data(ctx context.Context, tx transaction.Read, did string) (didplc.RegularOp, error) { ··· 208 208 for entry := range store.Consensus.AuditLogReverseIterator(ctx, tx, did, &iteratorErr) { 209 209 opEnum := entry.Operation 210 210 if opEnum.Tombstone != nil { 211 211 - return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDGone, "") 211 211 + return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDGone) 212 212 } 213 213 if opEnum.Regular != nil { 214 214 return *opEnum.Regular, nil ··· 216 216 return *modernizeOp(opEnum.Legacy), nil 217 217 } 218 218 if iteratorErr != nil { 219 219 - return didplc.RegularOp{}, stacktrace.Propagate(iteratorErr, "") 219 219 + return didplc.RegularOp{}, stacktrace.Propagate(iteratorErr) 220 220 } 221 221 222 222 - return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDNotFound, "") 222 222 + return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDNotFound) 223 223 } 224 224 225 225 func (plc *plcImpl) Export(ctx context.Context, tx transaction.Read, after uint64, count int) ([]types.SequencedLogEntry, error) { 226 226 entries, err := store.Consensus.ExportOperations(ctx, tx, after, count) 227 227 - return entries, stacktrace.Propagate(err, "") 227 227 + return entries, stacktrace.Propagate(err) 228 228 }

+18 -18

plc/operation_validator.go

··· 10 10 "github.com/bluesky-social/indigo/atproto/atcrypto" 11 11 "github.com/bluesky-social/indigo/atproto/syntax" 12 12 "github.com/did-method-plc/go-didplc" 13 13 - "github.com/palantir/stacktrace" 13 13 + "github.com/gbl08ma/stacktrace" 14 14 "github.com/samber/lo" 15 15 "github.com/samber/mo" 16 16 "tangled.org/gbl08ma.com/didplcbft/store" ··· 33 33 func (v *V0OperationValidator) Validate(ctx context.Context, readTx transaction.Read, timestamp syntax.Datetime, expectedDid string, opBytes []byte, laxChecking bool) (OperationEffects, error) { 34 34 opEnum, op, err := unmarshalOp(opBytes) 35 35 if err != nil { 36 36 - return OperationEffects{}, stacktrace.Propagate(errors.Join(ErrMalformedOperation, err), "") 36 36 + return OperationEffects{}, stacktrace.Propagate(errors.Join(ErrMalformedOperation, err)) 37 37 } 38 38 39 39 if !op.IsSigned() { 40 40 - return OperationEffects{}, stacktrace.Propagate(ErrOperationNotSigned, "") 40 40 + return OperationEffects{}, stacktrace.Propagate(ErrOperationNotSigned) 41 41 } 42 42 43 43 september29Of2023 := time.Date(2023, time.September, 28, 0, 0, 0, 0, time.UTC) ··· 45 45 // https://github.com/did-method-plc/did-method-plc/pull/47 (introduced rate limits and 'disallows create v1s' test) 46 46 // https://github.com/bluesky-social/atproto/discussions/1632 47 47 if !laxChecking && opEnum.Legacy != nil && !timestamp.Time().After(september29Of2023) { 48 48 - return OperationEffects{}, stacktrace.Propagate(ErrLegacyOperationNotAllowed, "") 48 48 + return OperationEffects{}, stacktrace.Propagate(ErrLegacyOperationNotAllowed) 49 49 } 50 50 51 51 if op.IsGenesis() { ··· 54 54 } 55 55 calcDid, err := op.DID() 56 56 if err != nil { 57 57 - return OperationEffects{}, stacktrace.Propagate(errors.Join(ErrMalformedOperation, err), "") 57 57 + return OperationEffects{}, stacktrace.Propagate(errors.Join(ErrMalformedOperation, err)) 58 58 } 59 59 if calcDid != expectedDid { 60 60 - return OperationEffects{}, stacktrace.Propagate(ErrDIDMismatch, "") 60 60 + return OperationEffects{}, stacktrace.Propagate(ErrDIDMismatch) 61 61 } 62 62 } 63 63 64 64 // Validate operation structure and field constraints 65 65 if !laxChecking && timestamp.Time().After(september29Of2023) { 66 66 if err := v.validateOperationConstraints(timestamp.Time(), op); err != nil { 67 67 - return OperationEffects{}, stacktrace.Propagate(err, "") 67 67 + return OperationEffects{}, stacktrace.Propagate(err) 68 68 } 69 69 } 70 70 ··· 100 100 } 101 101 102 102 if iteratorErr != nil { 103 103 - return OperationEffects{}, stacktrace.Propagate(iteratorErr, "") 103 103 + return OperationEffects{}, stacktrace.Propagate(iteratorErr) 104 104 } 105 105 106 106 // reverse entries to be in the order they were actually added ··· 126 126 } 127 127 } else if !proposedPrevOp.IsPresent() { 128 128 // there are entries in the audit log but none of them has a CID matching prev 129 129 - return OperationEffects{}, stacktrace.Propagate(ErrInvalidPrev, "") 129 129 + return OperationEffects{}, stacktrace.Propagate(ErrInvalidPrev) 130 130 } else { 131 131 // we've found the targeted prev operation 132 132 133 133 // timestamps must increase monotonically 134 134 mostRecentOp := relevantExistingEntries[len(relevantExistingEntries)-1] 135 135 if !timestamp.Time().After(mostRecentOp.CreatedAt) { 136 136 - return OperationEffects{}, stacktrace.Propagate(ErrInvalidOperationSequence, "") 136 136 + return OperationEffects{}, stacktrace.Propagate(ErrInvalidOperationSequence) 137 137 } 138 138 139 139 // if we are forking history, these are the ops still in the proposed canonical history ··· 148 148 149 149 _, err = didplc.VerifySignatureAny(op, morePowerfulKeys) 150 150 if err != nil { 151 151 - return OperationEffects{}, stacktrace.Propagate(ErrInvalidSignature, "") 151 151 + return OperationEffects{}, stacktrace.Propagate(ErrInvalidSignature) 152 152 } 153 153 154 154 // recovery key gets a 72hr window to do historical re-writes 155 155 if timestamp.Time().Sub(nullifiedEntries[0].CreatedAt) > 72*time.Hour { 156 156 - return OperationEffects{}, stacktrace.Propagate(ErrRecoveryWindowExpired, "") 156 156 + return OperationEffects{}, stacktrace.Propagate(ErrRecoveryWindowExpired) 157 157 } 158 158 } else { 159 159 // this does not involve nullification 160 160 _, err := didplc.VerifySignatureAny(op, lastOpRotationKeys) 161 161 if err != nil { 162 162 - return OperationEffects{}, stacktrace.Propagate(ErrInvalidSignature, "") 162 162 + return OperationEffects{}, stacktrace.Propagate(ErrInvalidSignature) 163 163 } 164 164 } 165 165 } ··· 178 178 if !laxChecking && timestamp.Time().After(september29Of2023) { 179 179 err = v.EnforceOpsRateLimit(ctx, readTx, expectedDid, timestamp.Time()) 180 180 if err != nil { 181 181 - return OperationEffects{}, stacktrace.Propagate(err, "") 181 181 + return OperationEffects{}, stacktrace.Propagate(err) 182 182 } 183 183 } 184 184 } ··· 252 252 } 253 253 } 254 254 } 255 255 - return stacktrace.Propagate(err, "") 255 255 + return stacktrace.Propagate(err) 256 256 } 257 257 258 258 func (v *V0OperationValidator) validateOperationConstraints(createdAt time.Time, op didplc.Operation) error { ··· 272 272 273 273 // Handle regular operations 274 274 if regular, ok := op.(*didplc.RegularOp); ok { 275 275 - return stacktrace.Propagate(v.validateRegularOpConstraints(createdAt, regular), "") 275 275 + return stacktrace.Propagate(v.validateRegularOpConstraints(createdAt, regular)) 276 276 } 277 277 278 278 // Handle legacy operations (creation only) 279 279 if legacy, ok := op.(*didplc.LegacyOp); ok { 280 280 - return stacktrace.Propagate(v.validateLegacyOpConstraints(createdAt, legacy), "") 280 280 + return stacktrace.Propagate(v.validateLegacyOpConstraints(createdAt, legacy)) 281 281 } 282 282 283 283 return stacktrace.Propagate(ErrMalformedOperation, "unknown operation type") ··· 289 289 } 290 290 291 291 // normalize the operation then use the regular validation 292 292 - return stacktrace.Propagate(v.validateRegularOpConstraints(createdAt, modernizeOp(op)), "") 292 292 + return stacktrace.Propagate(v.validateRegularOpConstraints(createdAt, modernizeOp(op))) 293 293 } 294 294 295 295 func (v *V0OperationValidator) validateRegularOpConstraints(createdAt time.Time, op *didplc.RegularOp) error {

+2 -2

plc/util.go

··· 4 4 "encoding/json" 5 5 6 6 "github.com/did-method-plc/go-didplc" 7 7 - "github.com/palantir/stacktrace" 7 7 + "github.com/gbl08ma/stacktrace" 8 8 "github.com/samber/lo" 9 9 ) 10 10 ··· 13 13 14 14 err := json.Unmarshal(opBytes, &opEnum) 15 15 if err != nil { 16 16 - return didplc.OpEnum{}, nil, stacktrace.Propagate(err, "") 16 16 + return didplc.OpEnum{}, nil, stacktrace.Propagate(err) 17 17 } 18 18 19 19 op := opEnum.AsOperation()

+1 -1

proof/writer/writer.go

··· 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" 12 12 + "github.com/gbl08ma/stacktrace" 13 13 "tangled.org/gbl08ma.com/didplcbft/proof" 14 14 ) 15 15

+65 -65

store/consensus.go

··· 17 17 ics23 "github.com/cosmos/ics23/go" 18 18 "github.com/dgraph-io/badger/v4" 19 19 "github.com/did-method-plc/go-didplc" 20 20 + "github.com/gbl08ma/stacktrace" 20 21 cbornode "github.com/ipfs/go-ipld-cbor" 21 21 - "github.com/palantir/stacktrace" 22 22 "github.com/polydawn/refmt/obj/atlas" 23 23 "github.com/samber/lo" 24 24 "github.com/samber/mo" ··· 94 94 func (t *consensusStore) AuditLog(ctx context.Context, tx transaction.Read, did string, withProof bool) ([]types.SequencedLogEntry, *ics23.CommitmentProof, error) { 95 95 didBytes, err := DIDToBytes(did) 96 96 if err != nil { 97 97 - return nil, nil, stacktrace.Propagate(err, "") 97 97 + return nil, nil, stacktrace.Propagate(err) 98 98 } 99 99 100 100 didRangeStart := marshalDIDLogKey(didBytes, 0) ··· 102 102 103 103 didLogIterator, err := tx.IndexDB().Iterator(didRangeStart, didRangeEnd) 104 104 if err != nil { 105 105 - return nil, nil, stacktrace.Propagate(err, "") 105 105 + return nil, nil, stacktrace.Propagate(err) 106 106 } 107 107 108 108 defer didLogIterator.Close() ··· 113 113 for didLogIterator.Valid() { 114 114 select { 115 115 case <-ctx.Done(): 116 116 - return nil, nil, stacktrace.Propagate(ctx.Err(), "") 116 116 + return nil, nil, stacktrace.Propagate(ctx.Err()) 117 117 default: 118 118 } 119 119 ··· 125 125 if txHeight >= validFromHeight && txHeight <= validToHeight { 126 126 operationValue, err := tx.Tree().Get(opKey) 127 127 if err != nil { 128 128 - return nil, nil, stacktrace.Propagate(err, "") 128 128 + return nil, nil, stacktrace.Propagate(err) 129 129 } 130 130 131 131 if withProof { 132 132 proof, err := tx.Tree().GetProof(opKey) 133 133 if err != nil { 134 134 - return nil, nil, stacktrace.Propagate(err, "") 134 134 + return nil, nil, stacktrace.Propagate(err) 135 135 } 136 136 proofs = append(proofs, proof) 137 137 } 138 138 139 139 logEntry, err := unmarshalLogEntry(opKey, operationValue) 140 140 if err != nil { 141 141 - return nil, nil, stacktrace.Propagate(err, "") 141 141 + return nil, nil, stacktrace.Propagate(err) 142 142 } 143 143 144 144 logEntries = append(logEntries, logEntry) ··· 148 148 149 149 err = didLogIterator.Error() 150 150 if err != nil { 151 151 - return nil, nil, stacktrace.Propagate(err, "") 151 151 + return nil, nil, stacktrace.Propagate(err) 152 152 } 153 153 154 154 var combinedProof *ics23.CommitmentProof ··· 167 167 168 168 didBytes, err := DIDToBytes(did) 169 169 if err != nil { 170 170 - *retErr = stacktrace.Propagate(err, "") 170 170 + *retErr = stacktrace.Propagate(err) 171 171 return 172 172 } 173 173 ··· 186 186 opts.Reverse = true 187 187 didLogIterator, err := tx.IndexDB().IteratorWithOptions(didRangeStart, didRangeEnd, opts) 188 188 if err != nil { 189 189 - *retErr = stacktrace.Propagate(err, "") 189 189 + *retErr = stacktrace.Propagate(err) 190 190 return 191 191 } 192 192 ··· 197 197 for didLogIterator.Valid() { 198 198 select { 199 199 case <-ctx.Done(): 200 200 - *retErr = stacktrace.Propagate(ctx.Err(), "") 200 200 + *retErr = stacktrace.Propagate(ctx.Err()) 201 201 return 202 202 default: 203 203 } ··· 210 210 if txHeight >= validFromHeight && txHeight <= validToHeight { 211 211 operationValue, err := tx.Tree().Get(opKey) 212 212 if err != nil { 213 213 - *retErr = stacktrace.Propagate(err, "") 213 213 + *retErr = stacktrace.Propagate(err) 214 214 return 215 215 } 216 216 217 217 logEntry, err := unmarshalLogEntry(opKey, operationValue) 218 218 if err != nil { 219 219 - *retErr = stacktrace.Propagate(err, "") 219 219 + *retErr = stacktrace.Propagate(err) 220 220 return 221 221 } 222 222 ··· 229 229 230 230 err = didLogIterator.Error() 231 231 if err != nil { 232 232 - *retErr = stacktrace.Propagate(err, "") 232 232 + *retErr = stacktrace.Propagate(err) 233 233 } 234 234 } 235 235 } ··· 262 262 263 263 opIterator, err := tx.Tree().Iterator(startKey, endKey, true) 264 264 if err != nil { 265 265 - *retErr = stacktrace.Propagate(err, "") 265 265 + *retErr = stacktrace.Propagate(err) 266 266 return 267 267 } 268 268 ··· 271 271 for opIterator.Valid() { 272 272 logEntry, err := unmarshalLogEntry(opIterator.Key(), opIterator.Value()) 273 273 if err != nil { 274 274 - *retErr = stacktrace.Propagate(err, "") 274 274 + *retErr = stacktrace.Propagate(err) 275 275 return 276 276 } 277 277 ··· 283 283 } 284 284 err = opIterator.Error() 285 285 if err != nil { 286 286 - *retErr = stacktrace.Propagate(err, "") 286 286 + *retErr = stacktrace.Propagate(err) 287 287 } 288 288 } 289 289 } ··· 293 293 func (t *consensusStore) StoreOperation(ctx context.Context, tx transaction.Write, entry didplc.LogEntry, nullifyWithSequenceEqualOrGreaterThan mo.Option[uint64]) error { 294 294 didBytes, err := DIDToBytes(entry.DID) 295 295 if err != nil { 296 296 - return stacktrace.Propagate(err, "") 296 296 + return stacktrace.Propagate(err) 297 297 } 298 298 299 299 txHeight := uint64(tx.Height()) ··· 307 307 opts.Reverse = true 308 308 didLogIterator, err := tx.IndexDB().IteratorWithOptions(didRangeStart, didRangeEnd, opts) 309 309 if err != nil { 310 310 - return stacktrace.Propagate(err, "") 310 310 + return stacktrace.Propagate(err) 311 311 } 312 312 313 313 defer didLogIterator.Close() ··· 317 317 for didLogIterator.Valid() { 318 318 select { 319 319 case <-ctx.Done(): 320 320 - return stacktrace.Propagate(ctx.Err(), "") 320 320 + return stacktrace.Propagate(ctx.Err()) 321 321 default: 322 322 } 323 323 ··· 334 334 335 335 operationValue, err := tx.Tree().Get(opKey) 336 336 if err != nil { 337 337 - return stacktrace.Propagate(err, "") 337 337 + return stacktrace.Propagate(err) 338 338 } 339 339 340 340 updated, err := tx.Tree().Set(opKey, markOperationValueNullified(operationValue)) 341 341 if err != nil { 342 342 - return stacktrace.Propagate(err, "") 342 342 + return stacktrace.Propagate(err) 343 343 } 344 344 if !updated { 345 345 // if we get to this point we have a mistake in our program, and the data is now inconsistent ··· 351 351 } 352 352 err = didLogIterator.Error() 353 353 if err != nil { 354 354 - return stacktrace.Propagate(err, "") 354 354 + return stacktrace.Propagate(err) 355 355 } 356 356 } 357 357 ··· 362 362 363 363 sequence, err := tx.NextSequence() 364 364 if err != nil { 365 365 - return stacktrace.Propagate(err, "") 365 365 + return stacktrace.Propagate(err) 366 366 } 367 367 368 368 operation := entry.Operation.AsOperation() ··· 371 371 372 372 updated, err := tx.Tree().Set(opKey, opValue) 373 373 if err != nil { 374 374 - return stacktrace.Propagate(err, "") 374 374 + return stacktrace.Propagate(err) 375 375 } 376 376 if updated { 377 377 // if we get to this point we have a mistake in our program, and the data is now inconsistent ··· 384 384 385 385 err = tx.IndexDB().Set(logKey, logValue) 386 386 if err != nil { 387 387 - return stacktrace.Propagate(err, "") 387 387 + return stacktrace.Propagate(err) 388 388 } 389 389 390 390 tx.AddToDIDBloomFilter(didBytes, sequence) ··· 397 397 398 398 opValue, err := tx.Tree().Get(opKey) 399 399 if err != nil { 400 400 - return stacktrace.Propagate(err, "") 400 400 + return stacktrace.Propagate(err) 401 401 } 402 402 if len(opValue) == 0 { 403 403 return stacktrace.NewError("operation %d not found", seqID) ··· 414 414 // we are not supposed to be able to recover from this error without rolling back the tree 415 415 return stacktrace.NewError("expected to be updating an existing operation key but wrote new one instead") 416 416 } 417 417 - return stacktrace.Propagate(err, "") 417 417 + return stacktrace.Propagate(err) 418 418 } 419 419 420 420 var minOperationKey = marshalOperationKey(0) ··· 425 425 426 426 itr, err := tx.Tree().Iterator(minOperationKey, maxOperationKey, false) 427 427 if err != nil { 428 428 - return 0, stacktrace.Propagate(err, "") 428 428 + return 0, stacktrace.Propagate(err) 429 429 } 430 430 431 431 defer itr.Close() ··· 433 433 if itr.Valid() { 434 434 seq, err = unmarshalOperationKey(itr.Key()) 435 435 if err != nil { 436 436 - return 0, stacktrace.Propagate(err, "") 436 436 + return 0, stacktrace.Propagate(err) 437 437 } 438 438 } 439 439 - return seq, stacktrace.Propagate(err, "") 439 439 + return seq, stacktrace.Propagate(err) 440 440 } 441 441 442 442 func DIDToBytes(did string) ([]byte, error) { ··· 526 526 527 527 did, err := bytesToDID(value[1:16]) 528 528 if err != nil { 529 529 - return false, "", time.Time{}, didplc.OpEnum{}, stacktrace.Propagate(err, "") 529 529 + return false, "", time.Time{}, didplc.OpEnum{}, stacktrace.Propagate(err) 530 530 } 531 531 532 532 createdAtUnixNano := binary.BigEndian.Uint64(value[16:24]) ··· 535 535 var opEnum didplc.OpEnum 536 536 err = cbornode.DecodeInto(value[24:], &opEnum) 537 537 if err != nil { 538 538 - return false, "", time.Time{}, didplc.OpEnum{}, stacktrace.Propagate(err, "") 538 538 + return false, "", time.Time{}, didplc.OpEnum{}, stacktrace.Propagate(err) 539 539 } 540 540 return nullified, did, createdAt, opEnum, nil 541 541 } ··· 549 549 func unmarshalLogEntry(operationKey, operationValue []byte) (types.SequencedLogEntry, error) { 550 550 nullified, actualDID, timestamp, operation, err := unmarshalOperationValue(operationValue) 551 551 if err != nil { 552 552 - return types.SequencedLogEntry{}, stacktrace.Propagate(err, "") 552 552 + return types.SequencedLogEntry{}, stacktrace.Propagate(err) 553 553 } 554 554 555 555 seq, err := unmarshalOperationKey(operationKey) 556 556 if err != nil { 557 557 - return types.SequencedLogEntry{}, stacktrace.Propagate(err, "") 557 557 + return types.SequencedLogEntry{}, stacktrace.Propagate(err) 558 558 } 559 559 560 560 return types.SequencedLogEntry{ ··· 591 591 // this is so stupid but oh well - maybe one day the entire thing will be upgraded to a less stupid cbor encoder 592 592 b, err := cbornode.DumpObject(x) 593 593 if err != nil { 594 594 - return didplc.OpEnum{}, stacktrace.Propagate(err, "") 594 594 + return didplc.OpEnum{}, stacktrace.Propagate(err) 595 595 } 596 596 597 597 switch typ { ··· 600 600 err = cbornode.DecodeInto(b, &o) 601 601 return didplc.OpEnum{ 602 602 Regular: o, 603 603 - }, stacktrace.Propagate(err, "") 603 603 + }, stacktrace.Propagate(err) 604 604 case "create": 605 605 o := &didplc.LegacyOp{} 606 606 err = cbornode.DecodeInto(b, &o) 607 607 return didplc.OpEnum{ 608 608 Legacy: o, 609 609 - }, stacktrace.Propagate(err, "") 609 609 + }, stacktrace.Propagate(err) 610 610 case "plc_tombstone": 611 611 o := &didplc.TombstoneOp{} 612 612 err = cbornode.DecodeInto(b, &o) 613 613 return didplc.OpEnum{ 614 614 Tombstone: o, 615 615 - }, stacktrace.Propagate(err, "") 615 615 + }, stacktrace.Propagate(err) 616 616 default: 617 617 return didplc.OpEnum{}, stacktrace.NewError("unexpected operation type: %s", typ) 618 618 } ··· 623 623 func (t *consensusStore) AuthoritativePLC(tx transaction.Read) (string, error) { 624 624 url, err := tx.Tree().Get([]byte(TreeAuthoritativePLCKey)) 625 625 if err != nil { 626 626 - return "", stacktrace.Propagate(err, "") 626 626 + return "", stacktrace.Propagate(err) 627 627 } 628 628 if url == nil { 629 629 return "", nil ··· 633 633 634 634 func (t *consensusStore) SetAuthoritativePLC(tx transaction.Write, url string) error { 635 635 _, err := tx.Tree().Set([]byte(TreeAuthoritativePLCKey), []byte(url)) 636 636 - return stacktrace.Propagate(err, "") 636 636 + return stacktrace.Propagate(err) 637 637 } 638 638 639 639 func (t *consensusStore) AuthoritativeImportProgress(tx transaction.Read) (uint64, error) { 640 640 progBytes, err := tx.Tree().Get([]byte(TreeAuthoritativeImportProgressKey)) 641 641 if err != nil { 642 642 - return 0, stacktrace.Propagate(err, "") 642 642 + return 0, stacktrace.Propagate(err) 643 643 } 644 644 if len(progBytes) != 8 { 645 645 return 0, nil ··· 652 652 binary.BigEndian.PutUint64(value, nextCursor) 653 653 654 654 _, err := tx.Tree().Set([]byte(TreeAuthoritativeImportProgressKey), value) 655 655 - return stacktrace.Propagate(err, "") 655 655 + return stacktrace.Propagate(err) 656 656 } 657 657 658 658 func marshalRangeChallengeCommitmentKey(validatorAddress []byte) []byte { ··· 686 686 key := marshalRangeChallengeCommitmentKey(validatorAddress) 687 687 value, err := tx.Tree().Get(key) 688 688 if err != nil { 689 689 - return 0, 0, 0, 0, nil, stacktrace.Propagate(err, "") 689 689 + return 0, 0, 0, 0, nil, stacktrace.Propagate(err) 690 690 } 691 691 if value == nil { 692 692 - return 0, 0, 0, 0, nil, stacktrace.Propagate(ErrNoActiveChallengeCommitment, "") 692 692 + return 0, 0, 0, 0, nil, stacktrace.Propagate(ErrNoActiveChallengeCommitment) 693 693 } 694 694 fromHeight, toHeight, provenHeight, includedOnHeight, treeRoot = unmarshalRangeChallengeCommitmentValue(value) 695 695 return ··· 701 701 value := marshalRangeChallengeCommitmentValue(fromHeight, toHeight, provenHeight, includedOnHeight, treeRoot) 702 702 // this may overwrite sometimes (e.g. if a previous commitment has expired and the validator needs to submit a new one) 703 703 _, err := tx.Tree().Set(key, value) 704 704 - return stacktrace.Propagate(err, "") 704 704 + return stacktrace.Propagate(err) 705 705 } 706 706 707 707 // ClearValidatorRangeChallengeCommitment implements [ConsensusStore]. 708 708 func (t *consensusStore) ClearValidatorRangeChallengeCommitment(tx transaction.Write, validatorAddress []byte) error { 709 709 _, removed, err := tx.Tree().Remove(marshalRangeChallengeCommitmentKey(validatorAddress)) 710 710 if err != nil { 711 711 - return stacktrace.Propagate(err, "") 711 711 + return stacktrace.Propagate(err) 712 712 } 713 713 if !removed { 714 714 // we are only expecting to call this after completing a range challenge, so we're expecting that the key would still exist ··· 730 730 key := marshalRangeChallengeCompletionKey(validatorAddress) 731 731 value, err := tx.Tree().Get(key) 732 732 if err != nil { 733 733 - return 0, stacktrace.Propagate(err, "") 733 733 + return 0, stacktrace.Propagate(err) 734 734 } 735 735 if value == nil { 736 736 - return 0, stacktrace.Propagate(ErrNoRecentChallengeCompletion, "") 736 736 + return 0, stacktrace.Propagate(ErrNoRecentChallengeCompletion) 737 737 } 738 738 return binary.BigEndian.Uint64(value), nil 739 739 } ··· 743 743 key := marshalRangeChallengeCompletionKey(validatorAddress) 744 744 value := binary.BigEndian.AppendUint64(nil, completedToHeight) 745 745 _, err := tx.Tree().Set(key, value) 746 746 - return stacktrace.Propagate(err, "") 746 746 + return stacktrace.Propagate(err) 747 747 } 748 748 749 749 func marshalBlockChallengeProofKey(block uint64) []byte { ··· 764 764 func (t *consensusStore) BlockChallengeProof(tx transaction.Read, height uint64) ([]byte, error) { 765 765 key := marshalBlockChallengeProofKey(height) 766 766 value, err := tx.IndexDB().Get(key) 767 767 - return value, stacktrace.Propagate(err, "") 767 767 + return value, stacktrace.Propagate(err) 768 768 } 769 769 770 770 func (t *consensusStore) BlockChalengeProofsIterator(tx transaction.Read, afterHeight uint64, retErr *error) iter.Seq2[uint64, []byte] { ··· 777 777 778 778 proofsIterator, err := tx.IndexDB().Iterator(startKey, endKey) 779 779 if err != nil { 780 780 - *retErr = stacktrace.Propagate(err, "") 780 780 + *retErr = stacktrace.Propagate(err) 781 781 return 782 782 } 783 783 ··· 794 794 } 795 795 err = proofsIterator.Error() 796 796 if err != nil { 797 797 - *retErr = stacktrace.Propagate(err, "") 797 797 + *retErr = stacktrace.Propagate(err) 798 798 } 799 799 } 800 800 } 801 801 802 802 func (t *consensusStore) StoreBlockChallengeProof(tx transaction.WriteIndex, blockHeight uint64, proof []byte) error { 803 803 err := tx.IndexDB().Set(marshalBlockChallengeProofKey(blockHeight), proof) 804 804 - return stacktrace.Propagate(err, "") 804 804 + return stacktrace.Propagate(err) 805 805 } 806 806 807 807 func (t *consensusStore) DeleteBlockChallengeProofsBelowHeight(ctx context.Context, tx transaction.WriteIndex, blockHeight uint64) error { ··· 811 811 812 812 proofsIterator, err := tx.IndexDB().Iterator(startKey, endKey) 813 813 if err != nil { 814 814 - return stacktrace.Propagate(err, "") 814 814 + return stacktrace.Propagate(err) 815 815 } 816 816 817 817 defer proofsIterator.Close() ··· 819 819 for proofsIterator.Valid() { 820 820 select { 821 821 case <-ctx.Done(): 822 822 - return stacktrace.Propagate(ctx.Err(), "") 822 822 + return stacktrace.Propagate(ctx.Err()) 823 823 default: 824 824 } 825 825 826 826 err = tx.IndexDB().Delete(slices.Clone(proofsIterator.Key())) 827 827 if err != nil { 828 828 - return stacktrace.Propagate(err, "") 828 828 + return stacktrace.Propagate(err) 829 829 } 830 830 831 831 proofsIterator.Next() ··· 846 846 847 847 value, err := tx.Tree().Get(key) 848 848 if err != nil { 849 849 - return 0, stacktrace.Propagate(err, "") 849 849 + return 0, stacktrace.Propagate(err) 850 850 } 851 851 852 852 // the following returns 0 if value is nil: ··· 859 859 860 860 value, err := tx.Tree().Get(key) 861 861 if err != nil { 862 862 - return stacktrace.Propagate(err, "") 862 862 + return stacktrace.Propagate(err) 863 863 } 864 864 865 865 reputation := new(big.Int).SetBytes(value) 866 866 reputation.Add(reputation, big.NewInt(change)) 867 867 if reputation.Sign() <= 0 { 868 868 _, _, err := tx.Tree().Remove(key) 869 869 - return stacktrace.Propagate(err, "") 869 869 + return stacktrace.Propagate(err) 870 870 } 871 871 872 872 _, err = tx.Tree().Set(key, reputation.Bytes()) 873 873 - return stacktrace.Propagate(err, "") 873 873 + return stacktrace.Propagate(err) 874 874 } 875 875 876 876 var minReputationKey = marshalValidatorReputationKey(make([]byte, 20)) ··· 896 896 toSet := make([]kv, 0, batchSize) 897 897 itr, err := tx.Tree().Iterator(startingKey, maxReputationKey, true) 898 898 if err != nil { 899 899 - return nil, false, stacktrace.Propagate(err, "") 899 899 + return nil, false, stacktrace.Propagate(err) 900 900 } 901 901 defer itr.Close() 902 902 ··· 929 929 for { 930 930 toSet, goAgain, err := batch() 931 931 if err != nil { 932 932 - return stacktrace.Propagate(err, "") 932 932 + return stacktrace.Propagate(err) 933 933 } 934 934 skipFirst = true 935 935 ··· 938 938 if s.value == nil { 939 939 _, updated, err = tx.Tree().Remove(s.key) 940 940 if err != nil { 941 941 - return stacktrace.Propagate(err, "") 941 941 + return stacktrace.Propagate(err) 942 942 } 943 943 } else { 944 944 updated, err = tx.Tree().Set(s.key, s.value) 945 945 if err != nil { 946 946 - return stacktrace.Propagate(err, "") 946 946 + return stacktrace.Propagate(err) 947 947 } 948 948 } 949 949

+15 -15

store/did_bloom.go

··· 10 10 11 11 "github.com/bits-and-blooms/bloom/v3" 12 12 cmtlog "github.com/cometbft/cometbft/libs/log" 13 13 - "github.com/palantir/stacktrace" 13 13 + "github.com/gbl08ma/stacktrace" 14 14 "tangled.org/gbl08ma.com/didplcbft/transaction" 15 15 ) 16 16 ··· 46 46 if errors.Is(err, os.ErrNotExist) { 47 47 return nil, 0, nil 48 48 } 49 49 - return nil, 0, stacktrace.Propagate(err, "") 49 49 + return nil, 0, stacktrace.Propagate(err) 50 50 } 51 51 52 52 headerBytes := make([]byte, 24) 53 53 n, err := file.Read(headerBytes) 54 54 if err != nil { 55 55 - return nil, 0, stacktrace.Propagate(err, "") 55 55 + return nil, 0, stacktrace.Propagate(err) 56 56 } 57 57 if n != 24 { 58 58 return nil, 0, stacktrace.NewError("malformed bloom filter file") ··· 69 69 70 70 _, err = f.ReadFrom(file) 71 71 if err != nil { 72 72 - return nil, 0, stacktrace.Propagate(err, "") 72 72 + return nil, 0, stacktrace.Propagate(err) 73 73 } 74 74 75 75 filter := &f ··· 79 79 for entry := range Consensus.OperationsIterator(tx, max(1, seq)-1, &iterErr) { 80 80 didBytes, err := DIDToBytes(entry.DID) 81 81 if err != nil { 82 82 - return nil, 0, stacktrace.Propagate(err, "") 82 82 + return nil, 0, stacktrace.Propagate(err) 83 83 } 84 84 filter.TestOrAdd(didBytes) 85 85 } 86 86 if iterErr != nil { 87 87 - return nil, 0, stacktrace.Propagate(err, "") 87 87 + return nil, 0, stacktrace.Propagate(err) 88 88 } 89 89 90 90 return filter, uint64(filter.ApproximatedSize()), nil 91 91 }() 92 92 if err != nil { 93 93 - return nil, stacktrace.Propagate(err, "") 93 93 + return nil, stacktrace.Propagate(err) 94 94 } 95 95 96 96 if filter != nil { ··· 111 111 112 112 iterator, err := tx.IndexDB().Iterator(didRangeStart, didRangeEnd) 113 113 if err != nil { 114 114 - return nil, stacktrace.Propagate(err, "") 114 114 + return nil, stacktrace.Propagate(err) 115 115 } 116 116 117 117 defer iterator.Close() ··· 125 125 } 126 126 err = iterator.Error() 127 127 if err != nil { 128 128 - return nil, stacktrace.Propagate(err, "") 128 128 + return nil, stacktrace.Propagate(err) 129 129 } 130 130 131 131 s.logger.Debug("rebuilt DID bloom filter", "itemCapacity", filterEstimatedItems, "itemCount", itemCount) ··· 140 140 141 141 file, err := os.OpenFile(s.filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644) 142 142 if err != nil { 143 143 - return stacktrace.Propagate(err, "") 143 143 + return stacktrace.Propagate(err) 144 144 } 145 145 defer file.Close() 146 146 147 147 // write reserved space for filter version 148 148 _, err = file.Write(make([]byte, 24)) 149 149 if err != nil { 150 150 - return stacktrace.Propagate(err, "") 150 150 + return stacktrace.Propagate(err) 151 151 } 152 152 153 153 version, size, cap, err := writeBloomTo(file) 154 154 if err != nil { 155 155 - return stacktrace.Propagate(err, "") 155 155 + return stacktrace.Propagate(err) 156 156 } 157 157 158 158 headerBytes := make([]byte, 24) ··· 163 163 // go back and write filter version 164 164 _, err = file.Seek(0, 0) 165 165 if err != nil { 166 166 - return stacktrace.Propagate(err, "") 166 166 + return stacktrace.Propagate(err) 167 167 } 168 168 169 169 _, err = file.Write(headerBytes) 170 170 if err != nil { 171 171 - return stacktrace.Propagate(err, "") 171 171 + return stacktrace.Propagate(err) 172 172 } 173 173 174 174 - return stacktrace.Propagate(err, "") 174 174 + return stacktrace.Propagate(err) 175 175 }

+10 -10

transaction/factory.go

··· 12 12 "github.com/cosmos/iavl" 13 13 "github.com/cosmos/iavl/db" 14 14 "github.com/dgraph-io/badger/v4" 15 15 - "github.com/palantir/stacktrace" 15 15 + "github.com/gbl08ma/stacktrace" 16 16 ) 17 17 18 18 type ExtendedDB interface { ··· 56 56 tx := f.ReadWorking(time.Now()) 57 57 f.bloomFilter, err = bloomFilterStorage.BuildDIDBloomFilter(tx) 58 58 if err != nil { 59 59 - return nil, stacktrace.Propagate(err, "") 59 59 + return nil, stacktrace.Propagate(err) 60 60 } 61 61 f.bloomSeq, err = f.operationCounter(tx) 62 62 // since the sequenceGetter always returns the next sequence 63 63 f.bloomSeq-- 64 64 - return f, stacktrace.Propagate(err, "") 64 64 + return f, stacktrace.Propagate(err) 65 65 } 66 66 67 67 func (f *Factory) ReadWorking(ts time.Time) Read { ··· 88 88 if err != nil { 89 89 // this should never happen, it's not worth making the signature of this function more 90 90 // complex for an error we'll never return unless the ABCI application is yet to be initialized 91 91 - panic(stacktrace.Propagate(err, "")) 91 91 + panic(stacktrace.Propagate(err)) 92 92 } 93 93 return tx 94 94 } ··· 97 97 immutable, err := f.mutableTree.GetImmutable(height) 98 98 if err != nil { 99 99 if !errors.Is(err, iavl.ErrVersionDoesNotExist) || height != 0 { 100 100 - return nil, stacktrace.Propagate(err, "") 100 100 + return nil, stacktrace.Propagate(err) 101 101 } 102 102 // give the reader an empty tree just to satisfy expectations 103 103 tmpTree := iavl.NewMutableTree(db.NewMemDB(), 1, false, iavl.NewNopLogger()) 104 104 _, v, err := tmpTree.SaveVersion() 105 105 if err != nil { 106 106 - return nil, stacktrace.Propagate(err, "") 106 106 + return nil, stacktrace.Propagate(err) 107 107 } 108 108 immutable, err = tmpTree.GetImmutable(v) 109 109 if err != nil { 110 110 - return nil, stacktrace.Propagate(err, "") 110 110 + return nil, stacktrace.Propagate(err) 111 111 } 112 112 } 113 113 return &readTx{ ··· 126 126 defer f.mutableTreeMu.Unlock() 127 127 128 128 tx, err := f.readHeightWithinMu(ts, height) 129 129 - return tx, stacktrace.Propagate(err, "") 129 129 + return tx, stacktrace.Propagate(err) 130 130 } 131 131 132 132 func (f *Factory) SaveDIDBloomFilter() error { ··· 161 161 if !math.IsInf(size, 0) { 162 162 sizeInt = uint64(math.Floor(size + 0.5)) 163 163 } 164 164 - return f.bloomSeq, sizeInt, curItemCap, stacktrace.Propagate(err, "") 164 164 + return f.bloomSeq, sizeInt, curItemCap, stacktrace.Propagate(err) 165 165 }) 166 166 167 167 if err != nil { 168 168 - return stacktrace.Propagate(err, "") 168 168 + return stacktrace.Propagate(err) 169 169 } 170 170 171 171 f.bloomLastSaveSeq = savedSeq

+3 -3

transaction/read_on_write_tx.go

··· 3 3 import ( 4 4 "time" 5 5 6 6 - "github.com/palantir/stacktrace" 6 6 + "github.com/gbl08ma/stacktrace" 7 7 ) 8 8 9 9 // readOnWriteTx is created from a write tx to allow a write tx to be passed to functions that accept a read-only transaction ··· 36 36 } 37 37 count, err := d.w.readTx.CountOperations() 38 38 if err != nil { 39 39 - return 0, stacktrace.Propagate(err, "") 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, "") 44 44 + return count, stacktrace.Propagate(err) 45 45 } 46 46 47 47 // Tree implements [Read].

+2 -2

transaction/read_tx.go

··· 6 6 7 7 "github.com/bits-and-blooms/bloom/v3" 8 8 "github.com/cosmos/iavl" 9 9 - "github.com/palantir/stacktrace" 9 9 + "github.com/gbl08ma/stacktrace" 10 10 ) 11 11 12 12 type readTx struct { ··· 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, "") 40 40 + return count, stacktrace.Propagate(err) 41 41 } 42 42 43 43 // Tree implements [Read].

+13 -13

transaction/write_index.go

··· 9 9 "cosmossdk.io/core/store" 10 10 dbm "github.com/cometbft/cometbft-db" 11 11 "github.com/dgraph-io/badger/v4" 12 12 - "github.com/palantir/stacktrace" 12 12 + "github.com/gbl08ma/stacktrace" 13 13 ) 14 14 15 15 // writeIndex provides write transactions with read uncommitted behavior ··· 25 25 func (w *writeIndex) Delete(key []byte) error { 26 26 err := w.batch.Delete(key) 27 27 if err != nil { 28 28 - return stacktrace.Propagate(err, "") 28 28 + return stacktrace.Propagate(err) 29 29 } 30 30 31 31 kstr := unsafeBytesToStr(key) ··· 39 39 func (w *writeIndex) Set(key []byte, value []byte) error { 40 40 err := w.batch.Set(key, value) 41 41 if err != nil { 42 42 - return stacktrace.Propagate(err, "") 42 42 + return stacktrace.Propagate(err) 43 43 } 44 44 45 45 kstr := unsafeBytesToStr(key) ··· 61 61 } 62 62 63 63 v, err := w.db.Get(key) 64 64 - return v, stacktrace.Propagate(err, "") 64 64 + return v, stacktrace.Propagate(err) 65 65 } 66 66 67 67 // Has implements [IndexWriter]. ··· 76 76 } 77 77 78 78 v, err := w.db.Has(key) 79 79 - return v, stacktrace.Propagate(err, "") 79 79 + return v, stacktrace.Propagate(err) 80 80 } 81 81 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, "") 85 85 + return v, stacktrace.Propagate(err) 86 86 } 87 87 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, "") 91 91 + return v, stacktrace.Propagate(err) 92 92 } 93 93 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, "") 97 97 + return v, stacktrace.Propagate(err) 98 98 } 99 99 100 100 func (w *writeIndex) Commit() error { 101 101 err := w.batch.Write() 102 102 if err != nil { 103 103 - return stacktrace.Propagate(err, "") 103 103 + return stacktrace.Propagate(err) 104 104 } 105 105 106 106 err = w.batch.Close() 107 107 if err != nil { 108 108 - return stacktrace.Propagate(err, "") 108 108 + return stacktrace.Propagate(err) 109 109 } 110 110 return nil 111 111 } ··· 113 113 func (w *writeIndex) Rollback() error { 114 114 err := w.batch.Close() 115 115 if err != nil { 116 116 - return stacktrace.Propagate(err, "") 116 116 + return stacktrace.Propagate(err) 117 117 } 118 118 return nil 119 119 } ··· 157 157 iter.underlyingIterator, err = db.ReverseIterator(start, end) 158 158 } 159 159 if err != nil { 160 160 - return nil, stacktrace.Propagate(err, "") 160 160 + return nil, stacktrace.Propagate(err) 161 161 } 162 162 163 163 // We need to ensure that we iterate over saved and unsaved state in order. ··· 296 296 297 297 // Close implements [dbm.Iterator] 298 298 func (iter *unsavedIterator) Close() error { 299 299 - return stacktrace.Propagate(iter.underlyingIterator.Close(), "") 299 299 + return stacktrace.Propagate(iter.underlyingIterator.Close()) 300 300 } 301 301 302 302 // Error implements [dbm.Iterator]

+3 -3

transaction/write_index_tx.go

··· 1 1 package transaction 2 2 3 3 - import "github.com/palantir/stacktrace" 3 3 + import "github.com/gbl08ma/stacktrace" 4 4 5 5 type writeIndexTx struct { 6 6 db ExtendedDB ··· 13 13 if w.writeIndex != nil { 14 14 err := w.writeIndex.Commit() 15 15 if err != nil { 16 16 - return stacktrace.Propagate(err, "") 16 16 + return stacktrace.Propagate(err) 17 17 } 18 18 } 19 19 ··· 25 25 if w.writeIndex != nil { 26 26 err := w.writeIndex.Rollback() 27 27 if err != nil { 28 28 - return stacktrace.Propagate(err, "") 28 28 + return stacktrace.Propagate(err) 29 29 } 30 30 } 31 31 return nil

+5 -5

transaction/write_tx.go

··· 3 3 import ( 4 4 "time" 5 5 6 6 - "github.com/palantir/stacktrace" 6 6 + "github.com/gbl08ma/stacktrace" 7 7 ) 8 8 9 9 type writeTx struct { ··· 27 27 func (w *writeTx) Commit() error { 28 28 _, _, err := w.readTx.mutableTree.SaveVersion() 29 29 if err != nil { 30 30 - return stacktrace.Propagate(err, "") 30 30 + return stacktrace.Propagate(err) 31 31 } 32 32 33 33 if w.writeIndex != nil { 34 34 err := w.writeIndex.Commit() 35 35 if err != nil { 36 36 - return stacktrace.Propagate(err, "") 36 36 + return stacktrace.Propagate(err) 37 37 } 38 38 } 39 39 ··· 55 55 if w.writeIndex != nil { 56 56 err := w.writeIndex.Rollback() 57 57 if err != nil { 58 58 - return stacktrace.Propagate(err, "") 58 58 + return stacktrace.Propagate(err) 59 59 } 60 60 } 61 61 return nil ··· 84 84 var err error 85 85 w.seq, err = w.readTx.operationCounter(w.readTx) 86 86 if err != nil { 87 87 - return 0, stacktrace.Propagate(err, "") 87 87 + return 0, stacktrace.Propagate(err) 88 88 } 89 89 } 90 90

+2 -2

tx_submitter.go

··· 9 9 "github.com/cometbft/cometbft/rpc/core" 10 10 coretypes "github.com/cometbft/cometbft/rpc/core/types" 11 11 cmttypes "github.com/cometbft/cometbft/types" 12 12 + "github.com/gbl08ma/stacktrace" 12 13 "github.com/google/uuid" 13 13 - "github.com/palantir/stacktrace" 14 14 "tangled.org/gbl08ma.com/didplcbft/types" 15 15 ) 16 16 ··· 24 24 func (t *txSubmitter) BroadcastTx(ctx context.Context, tx cmttypes.Tx, waitForInclusion bool) (*coretypes.ResultBroadcastTxCommit, error) { 25 25 uuid, err := uuid.NewRandom() 26 26 if err != nil { 27 27 - return nil, stacktrace.Propagate(err, "") 27 27 + return nil, stacktrace.Propagate(err) 28 28 } 29 29 subscriber := uuid.String() 30 30 eventBus := t.node.EventBus()