Generalize expiry based de-duplication, dsmr #1810

tsachiherman · 2024-11-22T15:35:09Z

What ?

Integrate the generic de-deduplication logic into the dsmr

x/dsmr/block.go

x/dsmr/node.go

aaronbuchwald · 2024-11-25T14:43:24Z

x/dsmr/node.go


-	return n.storage.SetMin(block.Timestamp, chunkIDs)
+func (n *Node[T]) GetExecutionBlock(ctx context.Context, blkID ids.ID) (validitywindow.ExecutionBlock[*ChunkCertificate], error) {


we can defer this to the VM to maintain a chain index for us that we pass in - similar to how we handle this in the existing chain/ package

aaronbuchwald · 2024-11-25T18:22:58Z

x/dsmr/node.go

@@ -172,19 +193,28 @@ func (n *Node[T]) BuildChunk(
 	return chunk, n.storage.AddLocalChunkWithCert(chunk, &chunkCert)
 }

-func (n *Node[T]) BuildBlock(parent Block, timestamp int64) (Block, error) {
-	if timestamp <= parent.Timestamp {
+// BuildBlock(ctx context.Context, parentView state.View, parent *ExecutionBlock) (*ExecutionBlock, *ExecutedBlock, merkledb.View, error)


can we remove this comment?

x/dsmr/node_test.go

tsachiherman · 2024-11-25T18:52:13Z

All sounds like great ideas, thanks!

…

On Mon, Nov 25, 2024, 1:27 PM aaronbuchwald ***@***.***> wrote: ***@***.**** commented on this pull request. ------------------------------ In x/dsmr/node.go <#1810 (comment)>: > @@ -172,19 +193,28 @@ func (n *Node[T]) BuildChunk( return chunk, n.storage.AddLocalChunkWithCert(chunk, &chunkCert) } -func (n *Node[T]) BuildBlock(parent Block, timestamp int64) (Block, error) { - if timestamp <= parent.Timestamp { +// BuildBlock(ctx context.Context, parentView state.View, parent *ExecutionBlock) (*ExecutionBlock, *ExecutedBlock, merkledb.View, error) can we remove this comment? ------------------------------ In x/dsmr/node_test.go <#1810 (comment)>: > +func newTestingLog() logging.Logger { + return logging.NewLogger("dsmr") +} we can replacing this with logging.NoLog{} ------------------------------ In x/dsmr/node_test.go <#1810 (comment)>: > +func newTestingTracer(t *testing.T) trace.Tracer { + tracer, err := trace.New(trace.Config{}) + require.NoError(t, err) + return tracer +} we can replace this with trace.Noop ------------------------------ In x/dsmr/node_test.go <#1810 (comment)>: > +type testingChainIndex struct{} + +func (*testingChainIndex) GetExecutionBlock(context.Context, ids.ID) (validitywindow.ExecutionBlock[*ChunkCertificate], error) { + return nil, nil +} + +func newChainIndexer() ChainIndex { + return &testingChainIndex{} +} We should add unit tests for the newly added functionality here. What do you think of the following cases? - skip duplicate chunks in build block - return an error if all available chunks are duplicates in build block - duplicate chunk within a block - duplicate chunk that between the block we are executing and the last accepted block - duplicate chunk inside of the accepted validity window - propagate an error if we fail to fetch a block during de-duplication — Reply to this email directly, view it on GitHub <#1810 (review)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AF2OOH6AKK7BDRFH2ESZGB32CNT2VAVCNFSM6AAAAABSJTMZI2VHI2DSMVQWIX3LMV43YUDVNRWFEZLROVSXG5CSMV3GSZLXHMZDINJZGMZDKMZVGM> . You are receiving this because you were assigned.Message ID: ***@***.***>

aaronbuchwald · 2024-11-29T17:53:18Z

internal/validitywindow/validitywindow.go

+	// make sure we have no repeats within the block itself.
+	blkTxsIDs := make(map[ids.ID]bool, len(blk.Txs()))
+	for _, tx := range blk.Txs() {
+		id := tx.GetID()
+		if _, has := blkTxsIDs[id]; has {
+			return fmt.Errorf("%w: duplicate in block", ErrDuplicateContainer)
+		}
+		blkTxsIDs[id] = true
+	}


We do this check twice now in chain since we previously handled this within NewExecutionBlock

We should only apply the check once, which do you think is the better place for it? The other addition within NewExecutionBlock is pre-populating the signature job. It would probably be better to remove that from the execution block and handle it in AsyncVerify. One good reason to do this is that handling this within ParseBlock can be a DoS vector.

I don't see why testing this twice is an issue on it's own, and I think that I have a better solution here;
Testing it in NewExecutionBlock is not ideal from my perspective, as it should be construction step ( i.e. no errors ).
How do you feel about the following:
in ExecutionBlock, we would add the following function:

func (b *ExecutionBlock) ValidateDuplicateTransactions() error { if len(b.Txs) != b.txsSet.Len() { ErrDuplicateTx } return nil

than in validitywindow.go VerifyExpiryReplayProtection, we can just call this method:

... if err := blk.ValidateDuplicateTransactions(); err != nil { return err } ...

and remove the test from NewExecutionBlock

aaronbuchwald · 2024-11-29T17:54:19Z

x/dsmr/block.go

+func (b Block) Contains(id ids.ID) bool {
+	for _, c := range b.ChunkCerts {
+		if c.ChunkID == id {
+			return true
+		}
+	}
+	return false
+}


Should we create a set of chunk cert IDs to make this faster? Could also leave for now and add only if needed.

I'm perfectly fine adding it. will do.

aaronbuchwald · 2024-11-29T17:55:03Z

x/dsmr/node.go

+type (
+	Node[T Tx] struct {
+		nodeID                       ids.NodeID
+		networkID                    uint32
+		chainID                      ids.ID
+		pk                           *bls.PublicKey
+		signer                       warp.Signer
+		getChunkClient               *TypedClient[*dsmr.GetChunkRequest, Chunk[T], []byte]
+		getChunkSignatureClient      *TypedClient[*dsmr.GetChunkSignatureRequest, *dsmr.GetChunkSignatureResponse, []byte]
+		chunkCertificateGossipClient *TypedClient[[]byte, []byte, *dsmr.ChunkCertificateGossip]
+		validators                   []Validator
+		validityWindow               timeValidityWindow
+
+		GetChunkHandler               *GetChunkHandler[T]
+		GetChunkSignatureHandler      *acp118.Handler
+		ChunkCertificateGossipHandler *ChunkCertificateGossipHandler[T]
+		storage                       *chunkStorage[T]
+		log                           logging.Logger
+		tracer                        trace.Tracer
+		validityWindowDuration        int64
+	}
+)


Can we remove the type declaration block in favor of simply declaring the node type? We do not use this style anywhere else in the codebase, so would prefer not to introduce it here.

aaronbuchwald · 2024-11-29T17:55:57Z

x/dsmr/node.go

+		if dup.Len() == len(chunkCerts) && len(chunkCerts) > 0 {
+			return Block{}, ErrAllChunkCertsDuplicate
+		}
 		return Block{}, ErrNoAvailableChunkCerts


Why differentiate this error? This handling seems overly complicated to provide a different error type

I thought that you've explicitly asked for a separate error when all the certs are duplicate.. did I get it wrong ?

Ah I meant a separate test case if we attempt to build an empty block: #1810

oh.. yes, I can do that.

aaronbuchwald · 2024-11-29T18:04:03Z

x/dsmr/node.go

+	if block.Tmstmp <= parentBlock.Tmstmp && parentBlock.Hght > 0 {
+		return ErrTimestampNotMonotonicallyIncreasing
+	}
+


Can we remove this check from this PR?

We should enforce timestamp >= parent timestamp (should allow them to be equal in case a block builder pushes the timestamp ahead of wall clock time for some nodes.

We should not allow the case that a malicious node builds a block with a timestamp that we consider valid less than 1s ahead of our wall clock time, but still ahead of our wall clock time, such that when we build a block on top of it, we fail because the current timestamp is ahead of our local timestamp.

We should update the check applied in BuildBlock imo.

We should also never execute the genesis block, so the check for parentBlock.Hght > 0 should be removed.

aaronbuchwald · 2024-11-29T18:05:35Z

x/dsmr/node_test.go

+	if blk, has := ti.blocks[id]; has {
+		return blk, nil
+	}
+	return nil, nil


Fetching a non-existing block should return an error, can we return database.ErrNotFound if the block is not available?

I find the ux of us using the sentinel database.ErrNotFound experience to be very awkward. This is due to the existing interface definition and not the changes in this PR though.... if we had something like GetExecutionBlock() (ExecutionBlock[T], bool, error) we wouldn't have to introspect the error and could just return an error if error is non-nil and check the bool if it just wasn't there.

joshua-kim · 2024-12-03T18:37:42Z

internal/validitywindow/validitywindow.go

@@ -69,6 +70,15 @@ func (v *TimeValidityWindow[Container]) VerifyExpiryReplayProtection(
 	if dup.Len() > 0 {
 		return fmt.Errorf("%w: duplicate in ancestry", ErrDuplicateContainer)
 	}
+	// make sure we have no repeats within the block itself.
+	blkTxsIDs := make(map[ids.ID]bool, len(blk.Txs()))


Can we use set.Set here?

joshua-kim · 2024-12-03T18:41:44Z

x/dsmr/certificate.go

+func (c ChunkCertificate) GetExpiry() int64 { return c.Expiry }

 func (c *ChunkCertificate) GetSlot() int64 { return c.Expiry }


I think these are duplicated - GetSlot is meant to be Expiry

joshua-kim · 2024-12-03T18:43:57Z

x/dsmr/node.go

+	log logging.Logger,
+	tracer trace.Tracer,
+	chainIndex ChainIndex,
+	validityWindowDuration int64,


Should we use time.Duration here?

joshua-kim · 2024-12-03T18:44:57Z

x/dsmr/node.go

+	oldestAllowed := timestamp - n.validityWindowDuration
+	if oldestAllowed < 0 {
+		oldestAllowed = 0
+	}


nit: min(0, oldestAllowed)

joshua-kim · 2024-12-03T18:46:12Z

x/dsmr/node_test.go

+	blocks map[ids.ID]validitywindow.ExecutionBlock[*ChunkCertificate]
+}
+
+func (ti *testingChainIndex) GetExecutionBlock(_ context.Context, id ids.ID) (validitywindow.ExecutionBlock[*ChunkCertificate], error) {


Nits:

receiver name should just be t

id -> blkID or blockID

joshua-kim · 2024-12-03T19:21:00Z

x/dsmr/block.go

 func (b Block) GetID() ids.ID {
 	return b.blkID
 }
+
+func (b Block) Parent() ids.ID {


I don't care which we pick, but we should be consistent on the naming of either Foo() or GetFoo().

I'm going to dodge this one by saying that this method is no longer needed.

joshua-kim · 2024-12-03T19:21:14Z

x/dsmr/block.go

+func (b Block) Txs() []*ChunkCertificate {
+	return b.ChunkCerts
+}


This seems weird because these are not returning txs

yes, I agree. let's discuss this as a group ?

Can we use the term containers?

joshua-kim · 2024-12-03T19:21:27Z

x/dsmr/node.go

+	log logging.Logger,
+	tracer trace.Tracer,


nit: make these (logger + tracer) the first args in this fn

joshua-kim · 2024-12-03T19:22:38Z

x/dsmr/node.go

+type (
+	ChainIndex         = validitywindow.ChainIndex[*ChunkCertificate]
+	timeValidityWindow = *validitywindow.TimeValidityWindow[*ChunkCertificate]
+)


Seems like we're doing this to avoid the caller depending on an internal package. I'm wondering if it even makes sense for validitywindow to be in internal at all... should this just be merged into dsmr?

@aaronbuchwald asked to remove this section completely.

joshua-kim · 2024-12-03T19:26:11Z

x/dsmr/block.go

 	"github.com/ava-labs/hypersdk/utils"
 )

 const InitialChunkSize = 250 * 1024

 type Tx interface {
-	GetID() ids.ID
-	GetExpiry() int64
+	emap.Item


This exposes the internal/emap package into the caller. I think the previous wrapping pattern where we wrapped this interface w/ a type that implemented the emap interface actually looked cleaner.

once merged, we won't need wrapping interface anymore. . unless I'm missing something ?

I think @joshua-kim 's point is to have the internal type implemented as makes sense in this package and then wrap it with another type that converts between that structure and the required interface when we need to use it in the validity window or expiry map where we need a specific interface. Correct me if I'm wrong @joshua-kim

aaronbuchwald · 2024-12-06T15:41:55Z

x/dsmr/block.go

+func (b Block) Txs() []*ChunkCertificate {
+	return b.ChunkCerts
+}


Can we use the term containers?

aaronbuchwald · 2024-12-06T15:44:33Z

x/dsmr/node.go

+		if dup.Len() == len(chunkCerts) && len(chunkCerts) > 0 {
+			return Block{}, ErrAllChunkCertsDuplicate
+		}
 		return Block{}, ErrNoAvailableChunkCerts


Ah I meant a separate test case if we attempt to build an empty block: #1810

aaronbuchwald · 2024-12-06T15:47:26Z

x/dsmr/block.go

 	"github.com/ava-labs/hypersdk/utils"
 )

 const InitialChunkSize = 250 * 1024

 type Tx interface {
-	GetID() ids.ID
-	GetExpiry() int64
+	emap.Item


I think @joshua-kim 's point is to have the internal type implemented as makes sense in this package and then wrap it with another type that converts between that structure and the required interface when we need to use it in the validity window or expiry map where we need a specific interface. Correct me if I'm wrong @joshua-kim

aaronbuchwald · 2024-12-06T15:48:18Z

internal/validitywindow/dependencies.go

 }

 type ChainIndex[Container emap.Item] interface {
-	GetExecutionBlock(ctx context.Context, blkID ids.ID) (ExecutionBlock[Container], error)
+	GetExecutionBlock(ctx context.Context, blkID ids.ID) (ExecutionBlock[Container], bool, error)


Why are we adding the boolean here?

My guess is that this is to return true/false, and use the error if something goes wrong instead of just returning the block type + an error, and you have to introspect the error using a check against database.ErrNotFound.

@aaronbuchwald see @joshua-kim's request above to change the function signature to GetExecutionBlock() (ExecutionBlock[T], bool, error)

When is it valid to not have an execution block that the validity window requests?

We should always have a window of blocks that goes past the time validity window. I am not sure of any case where not having a block ie. returning false should not also be treated as an error. Unless there is such a case, I think we're better off just returning an error and not adding to the return type here.

aaronbuchwald · 2024-12-06T15:51:31Z

internal/validitywindow/validitywindow.go

-	parent, err := v.chainIndex.GetExecutionBlock(ctx, blk.Parent())
-	if err != nil {
+	parent, hasBlock, err := v.chainIndex.GetExecutionBlock(ctx, blk.Parent())
+	if err != nil || !hasBlock {


I don't think we should return a boolean for hasBlock here, but if we did not have the block, we would not be able correctly verify the block. It's not safe to mark a block as passing verification if we are missing the information required to verify it, we must guarantee we don't reach a point like that in the first place.

you're correct. I'll be adding an error case here which would be returned in case the hasBlock is false ( since it shouldn't happen ).

joshua-kim · 2024-12-06T20:31:14Z

x/dsmr/node_test.go

+	blk := Block{
+		ParentID: ids.GenerateTestID(),
+		Hght:     1,
+		Tmstmp:   1,
+		blkID:    ids.GenerateTestID(),
+	}


We should be building this block through node.BuildBlock and calling Verify prior to calling Accept (see other tests as an example). This is technically not a valid block because it references an unknown parent instead of the last accepted block which would be caught if Verify was called on it. Building a block should generally take the form of calling BuildChunk -> BuildBlock -> Verify -> Accept

joshua-kim · 2024-12-06T20:33:50Z

x/dsmr/node_test.go

+	}
+	r.NoError(node.Accept(context.Background(), blk))
+
+	r.NoError(node.storage.AddLocalChunkWithCert(chunk, &chunkCert))


We shouldn't have to call this, since the chunk cert is already added locally once the chunk is finished being built from node.BuildChunk, and remote chunks are added within Accept if we don't have them (ref).

I also think this is a weird way of writing the test because we're manually injecting the chunk into the database instead of testing how this would happen through the actual user-flow of dsmr. Maybe a better way would be to test the cases where you are calling BuildChunk a second time w/ the same args to make a duplicate chunk, and trying to build + accept the block? We should also test the case where a peer sends us a block referencing a duplicate chunk that we try to verify and fail.

joshua-kim · 2024-12-06T20:54:11Z

x/dsmr/node_test.go

+	initChunks := func(node *Node[tx]) ([]Chunk[tx], []*ChunkCertificate) {
+		var chunks []Chunk[tx]
+		var chunksCerts []*ChunkCertificate
+		for expiry := int64(0); expiry < 5; expiry++ {
+			chunk, cert, err := node.BuildChunk(
+				context.Background(),
+				[]tx{
+					{
+						ID:     ids.GenerateTestID(),
+						Expiry: expiry,
+					},
+				},
+				expiry,
+				codec.Address{},
+			)
+			r.NoError(err)
+			chunks = append(chunks, chunk)
+			chunksCerts = append(chunksCerts, &cert)
+		}
+		return chunks, chunksCerts
+	}


Can we just move this to the test body? It's only used once so I find that this makes the test more confusing to read.

joshua-kim · 2024-12-06T20:55:56Z

x/dsmr/node_test.go

+		}
+		return chunks, chunksCerts
+	}
+	testCases := []struct {


nit: In our codebase we usually just call this tests

joshua-kim · 2024-12-06T21:18:16Z

x/dsmr/node_test.go

+			indexer := newTestingChainIndexer()
+			valWind := testCase.validalidityWindowDuration
+			if valWind == 0 {
+				valWind = testingDefaultValidityWindowDuration
+			}
+
+			getChunkPeers := make(map[ids.NodeID]p2p.Handler)
+
+			chunkCertGossipPeers := make(map[ids.NodeID]p2p.Handler)
+
+			chunkStorage, err := NewChunkStorage[tx](NoVerifier[tx]{}, memdb.New())
+			require.NoError(t, err)
+
+			getChunkHandler := &GetChunkHandler[tx]{
+				storage: chunkStorage,
+			}
+			chunkSignatureRequestHandler := acp118.NewHandler(ChunkSignatureRequestVerifier[tx]{
+				verifier: NoVerifier[tx]{},
+				storage:  chunkStorage,
+			}, signer)
+			chunkCertificateGossipHandler := ChunkCertificateGossipHandler[tx]{
+				storage: chunkStorage,
+			}
+			genesisBlk := Block{
+				ParentID: ids.Empty,
+				Hght:     0,
+				Tmstmp:   0,
+				blkID:    ids.Empty,
+			}
+
+			nodeID := ids.GenerateTestNodeID()
+
+			validators := []Validator{
+				{
+					NodeID:    nodeID,
+					Weight:    1,
+					PublicKey: pk,
+				},
+			}
+
+			chunkSignaturePeers := map[ids.NodeID]p2p.Handler{
+				nodeID: chunkSignatureRequestHandler,
+			}
+
+			node, err := New[tx](
+				logging.NoLog{},
+				trace.Noop,
+				nodeID,
+				networkID,
+				chainID,
+				pk,
+				signer,
+				chunkStorage,
+				getChunkHandler,
+				chunkSignatureRequestHandler,
+				chunkCertificateGossipHandler,
+				p2ptest.NewClientWithPeers(
+					t,
+					context.Background(),
+					ids.EmptyNodeID,
+					getChunkHandler,
+					getChunkPeers,
+				),
+				p2ptest.NewClientWithPeers(
+					t,
+					context.Background(),
+					ids.EmptyNodeID,
+					chunkSignatureRequestHandler,
+					chunkSignaturePeers,
+				),
+				p2ptest.NewClientWithPeers(
+					t,
+					context.Background(),
+					ids.EmptyNodeID,
+					chunkCertificateGossipHandler,
+					chunkCertGossipPeers,
+				),
+				validators,
+				genesisBlk,
+				1,
+				1,
+				indexer,
+				valWind,
+			)
+			r.NoError(err)
+


Can we use newTestNode here? I think it would simplify a lot of the setup

joshua-kim · 2024-12-06T21:21:44Z

x/dsmr/node_test.go

@@ -38,6 +40,29 @@ var (
 	chainID = ids.Empty
 )

+const testingDefaultValidityWindowDuration = time.Duration(5)


nit: can we move this to a const block at the top of the file?

joshua-kim · 2024-12-06T21:21:52Z

x/dsmr/node_test.go

@@ -38,6 +40,29 @@ var (
 	chainID = ids.Empty
 )

+const testingDefaultValidityWindowDuration = time.Duration(5)
+
+type testingChainIndex struct {


nit: can we call this something like testValidityWindow + an interface check at the top of this file?

joshua-kim · 2024-12-06T21:24:59Z

internal/validitywindow/dependencies.go

 }

 type ChainIndex[Container emap.Item] interface {
-	GetExecutionBlock(ctx context.Context, blkID ids.ID) (ExecutionBlock[Container], error)
+	GetExecutionBlock(ctx context.Context, blkID ids.ID) (ExecutionBlock[Container], bool, error)


My guess is that this is to return true/false, and use the error if something goes wrong instead of just returning the block type + an error, and you have to introspect the error using a check against database.ErrNotFound.

joshua-kim · 2024-12-06T21:27:10Z

internal/validitywindow/syncer.go

 	)
 	for {
-		parent, err = s.chainIndex.GetExecutionBlock(ctx, parent.Parent())
-		if err != nil {
+		parent, hasBlock, err = s.chainIndex.GetExecutionBlock(ctx, parent.Parent())


nit: ok is usually idiomatic in go for existence checks

aaronbuchwald · 2024-12-12T22:16:14Z

x/dsmr/block.go

+	return e.innerBlock.ParentID
+}
+
+func (e ExecutionBlock) Txs() []*emapChunkCertificate {


Can we rename this to a neutral name instead of txs like containers?

eliminate emapChunk

e5ecf69

tsachiherman self-assigned this Nov 22, 2024

tsachiherman added 2 commits November 22, 2024 11:52

update

ba644c3

update

2939543

aaronbuchwald reviewed Nov 25, 2024

View reviewed changes

tsachiherman added 6 commits November 25, 2024 10:09

Merge branch 'main' into tsachi/refactor_validity_window3

08f0d59

update per CR

659f1fb

lint

921b908

apply requested changes.

508cc92

fix code + test.

7a3fed6

rollback unneeded changes.

b312a3c

tsachiherman marked this pull request as ready for review November 25, 2024 18:20

tsachiherman requested a review from joshua-kim as a code owner November 25, 2024 18:20

rename testing chain indexer.

1238460

aaronbuchwald reviewed Nov 25, 2024

View reviewed changes

tsachiherman added 8 commits November 25, 2024 15:04

update

8c1ab98

add unit test.

f8e42a8

update unit test.

b000edf

Merge branch 'main' into tsachi/refactor_validity_window3

1d2536e

lint

6911f26

update

f2816e7

lint

e78f847

update

270245a

aaronbuchwald reviewed Nov 29, 2024

View reviewed changes

joshua-kim mentioned this pull request Dec 2, 2024

Generate Warp Signatures #1818

Merged

joshua-kim reviewed Dec 3, 2024

View reviewed changes

tsachiherman added 3 commits December 5, 2024 11:25

Merge branch 'main' into tsachi/refactor_validity_window3

144ddd4

fix few CR feedback.

2fa701d

add certSet

2220b5e

tsachiherman added 4 commits December 6, 2024 09:28

remove type declaration block.

39905b9

fix tests

d54e1a0

update

8e83b6d

update

fdd4639

aaronbuchwald reviewed Dec 6, 2024

View reviewed changes

joshua-kim reviewed Dec 6, 2024

View reviewed changes

tsachiherman added 13 commits December 9, 2024 10:14

update

9e127f1

create a wrapper for the block in dsmr (#1829)

0f3fe73

update

fc87f31

update

cf82891

updatge

864acc1

fix typo

d96160e

undo unwanted changes

9ea09b4

update

30bcdce

update

8d52c05

update unit test

32207b9

update test

5d62af7

update

7ca779b

update

383a7ef

tsachiherman requested review from joshua-kim and aaronbuchwald December 12, 2024 22:10

aaronbuchwald reviewed Dec 12, 2024

View reviewed changes

update per review feedback,.

7902a6a


		return n.storage.SetMin(block.Timestamp, chunkIDs)
		func (n Node[T]) GetExecutionBlock(ctx context.Context, blkID ids.ID) (validitywindow.ExecutionBlock[ChunkCertificate], error) {

		func (c ChunkCertificate) GetExpiry() int64 { return c.Expiry }

		func (c *ChunkCertificate) GetSlot() int64 { return c.Expiry }

Generalize expiry based de-duplication, dsmr #1810

Are you sure you want to change the base?

Generalize expiry based de-duplication, dsmr #1810

Conversation

tsachiherman commented Nov 22, 2024 • edited Loading

What ?

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tsachiherman commented Nov 25, 2024 via email

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tsachiherman Dec 10, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

aaronbuchwald Dec 12, 2024 • edited Loading

Choose a reason for hiding this comment

tsachiherman commented Nov 22, 2024 •

edited

Loading

tsachiherman Dec 10, 2024 •

edited

Loading

aaronbuchwald Dec 12, 2024 •

edited

Loading