Merge pull request #1794 from lightninglabs/feat/filter-by-timestamp-addr-receives

Filter AddrReceives by timestamp

Author: ffranr

address/event.go

@@ -60,6 +60,11 @@ type EventQueryParams struct {
 	// (inclusive). Can be set to nil to return events of all creation
 	// times.
 	CreationTimeFrom *time.Time
+
+	// CreationTimeTo is the latest creation time to query for
+	// (inclusive). Can be set to nil to return events of all creation
+	// times.
+	CreationTimeTo *time.Time
 }
 
 // AssetOutput holds the information about a single asset output that was sent

cmd/commands/addrs.go

@@ -283,6 +283,16 @@ var receivesAddrCommand = cli.Command{
 			Name:  addrName,
 			Usage: "show transfers of a single address only",
 		},
+		cli.Uint64Flag{
+			Name: "start_timestamp",
+			Usage: "filter transfers created after this + " +
+				"unix timestamp (seconds)",
+		},
+		cli.Uint64Flag{
+			Name: "end_timestamp",
+			Usage: "filter transfers created before this + " +
+				"unix timestamp (seconds)",
+		},
 	},
 	Action: addrReceives,
 }
@@ -302,7 +312,9 @@ func addrReceives(ctx *cli.Context) error {
 	}
 
 	resp, err := client.AddrReceives(ctxc, &taprpc.AddrReceivesRequest{
-		FilterAddr: addr,
+		FilterAddr:     addr,
+		StartTimestamp: ctx.Uint64("start_timestamp"),
+		EndTimestamp:   ctx.Uint64("end_timestamp"),
 	})
 	if err != nil {
 		return fmt.Errorf("unable to query addr receives: %w", err)

docs/release-notes/release-notes-0.7.0.md

@@ -168,6 +168,9 @@
   user to specify a custom amount to send to a V2 address that doesn't have an
   amount specified.
 
+- The `AddrReceives` RPC now supports timestamp filtering with
+  [new `StartTimestamp` and `EndTimestamp` fields](https://github.com/lightninglabs/taproot-assets/pull/1794).
+
 ## tapcli Additions
 
 - [Rename](https://github.com/lightninglabs/taproot-assets/pull/1682) the mint
@@ -186,6 +189,9 @@
   includes unset and zero-valued proto fields (e.g. transaction output indexes).
   This ensures consistent output shape across all proto messages.
 
+- The `tapcli addrs receives` command now supports 
+  [new `--start_timestamp` and `--end_timestamp` flags](https://github.com/lightninglabs/taproot-assets/pull/1794).
+
 # Improvements
 
 ## Functional Updates

itest/addrs_test.go

@@ -873,6 +873,146 @@ func testUnknownTlvType(t *harnessTest) {
 	require.False(t.t, verifyResp.Valid)
 }
 
+// testAddrReceives tests the fetching of address events.
+func testAddrReceives(t *harnessTest) {
+	// First, mint an asset so we have something to create addresses for.
+	rpcAssets := MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner().Client, t.tapd,
+		[]*mintrpc.MintAssetRequest{
+			simpleAssets[0],
+		},
+	)
+	asset := rpcAssets[0]
+
+	ctxb := context.Background()
+	ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout)
+	defer cancel()
+
+	// Create a second node that'll be the receiver.
+	bobLnd := t.lndHarness.NewNodeWithCoins("Bob", nil)
+	bob := setupTapdHarness(t.t, t, bobLnd, t.universeServer)
+	defer func() {
+		require.NoError(t.t, bob.stop(!*noDelete))
+	}()
+
+	// Create an address and send assets to it.
+	addr, events := NewAddrWithEventStream(
+		t.t, bob, &taprpc.NewAddrRequest{
+			AssetId:      asset.AssetGenesis.AssetId,
+			Amt:          asset.Amount - 1,
+			AssetVersion: asset.Version,
+		},
+	)
+
+	AssertAddrCreated(t.t, bob, asset, addr)
+
+	// Record the time before sending.
+	timeBeforeSend := time.Now()
+
+	// Send assets to the address.
+	sendResp, sendEvents := sendAssetsToAddr(t, t.tapd, addr)
+	require.NotNil(t.t, sendResp)
+
+	// Wait for the event to be detected.
+	AssertAddrEvent(t.t, bob, addr, 1, statusDetected)
+
+	// Mine a block to confirm the transaction.
+	MineBlocks(t.t, t.lndHarness.Miner().Client, 1, 1)
+
+	// Wait for the event to be confirmed.
+	AssertAddrEvent(t.t, bob, addr, 1, statusConfirmed)
+
+	// Record the time after sending.
+	timeAfterSend := time.Now()
+
+	// Wait for the receive to complete.
+	AssertNonInteractiveRecvComplete(t.t, bob, 1)
+	AssertSendEventsComplete(t.t, addr.ScriptKey, sendEvents)
+	AssertReceiveEvents(t.t, addr, events)
+
+	// Test 1: Get all events without timestamp filtering.
+	resp, err := bob.AddrReceives(
+		ctxt, &taprpc.AddrReceivesRequest{},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, resp.Events, 1)
+
+	// Test 2: Filter by start timestamp before the send
+	// (should return events).
+	resp, err = bob.AddrReceives(
+		ctxt, &taprpc.AddrReceivesRequest{
+			StartTimestamp: uint64(timeBeforeSend.Unix()),
+		},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, resp.Events, 1)
+
+	// Test 3: Filter by start timestamp exactly at the send time
+	// (should return the event).
+	resp, err = bob.AddrReceives(
+		ctxt, &taprpc.AddrReceivesRequest{
+			StartTimestamp: uint64(timeBeforeSend.Unix()),
+		},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, resp.Events, 1)
+
+	// Test 4: Filter by address and start timestamp.
+	resp, err = bob.AddrReceives(
+		ctxt, &taprpc.AddrReceivesRequest{
+			FilterAddr:     addr.Encoded,
+			StartTimestamp: uint64(timeBeforeSend.Unix()),
+		},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, resp.Events, 1)
+	require.Equal(
+		t.t, addr.Encoded, resp.Events[0].Addr.Encoded,
+	)
+
+	// Test 5: Filter by address and start timestamp after send
+	// (should return no events).
+	resp, err = bob.AddrReceives(
+		ctxt, &taprpc.AddrReceivesRequest{
+			FilterAddr:     addr.Encoded,
+			StartTimestamp: uint64(timeAfterSend.Unix() + 1),
+		},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, resp.Events, 0)
+
+	// Test 6: Filter by end timestamp before the send
+	// (should return no events).
+	resp, err = bob.AddrReceives(
+		ctxt, &taprpc.AddrReceivesRequest{
+			EndTimestamp: uint64(timeBeforeSend.Unix()),
+		},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, resp.Events, 0)
+
+	// Test 7: Filter by end timestamp after the send
+	// (should return the event).
+	resp, err = bob.AddrReceives(
+		ctxt, &taprpc.AddrReceivesRequest{
+			EndTimestamp: uint64(timeAfterSend.Unix() + 1),
+		},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, resp.Events, 1)
+
+	// Test 8: Filter by both start and end timestamp
+	// (should return the event).
+	resp, err = bob.AddrReceives(
+		ctxt, &taprpc.AddrReceivesRequest{
+			StartTimestamp: uint64(timeBeforeSend.Unix()),
+			EndTimestamp:   uint64(timeAfterSend.Unix() + 1),
+		},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, resp.Events, 1)
+}
+
 // sendProof manually exports a proof from the given source node and imports it
 // using the development only ImportProof RPC on the destination node.
 func sendProof(t *harnessTest, src, dst *tapdHarness,

itest/test_list_on_test.go

@@ -53,6 +53,10 @@ var allTestCases = []*testCase{
 		name: "addresses",
 		test: testAddresses,
 	},
+	{
+		name: "address receives",
+		test: testAddrReceives,
+	},
 	{
 		name: "multi address",
 		test: testMultiAddress,

rpcserver.go

@@ -2271,6 +2271,16 @@ func (r *rpcServer) AddrReceives(ctx context.Context,
 		sqlQuery.StatusTo = &status
 	}
 
+	// Add timestamp filtering if specified
+	if req.StartTimestamp > 0 {
+		startTime := time.Unix(int64(req.StartTimestamp), 0)
+		sqlQuery.CreationTimeFrom = &startTime
+	}
+	if req.EndTimestamp > 0 {
+		endTime := time.Unix(int64(req.EndTimestamp), 0)
+		sqlQuery.CreationTimeTo = &endTime
+	}
+
 	events, err := r.cfg.AddrBook.QueryEvents(ctx, sqlQuery)
 	if err != nil {
 		return nil, fmt.Errorf("error querying events: %w", err)
@@ -4154,12 +4164,6 @@ func (r *rpcServer) FetchSupplyCommit(ctx context.Context,
 	req *unirpc.FetchSupplyCommitRequest) (
 	*unirpc.FetchSupplyCommitResponse, error) {
 
-	// Check the rate limiter to see if we need to wait at all. If not then
-	// this'll be a noop.
-	if err := r.proofQueryRateLimiter.Wait(ctx); err != nil {
-		return nil, err
-	}
-
 	groupPubKey, err := unmarshalGroupKey(
 		req.GetGroupKeyBytes(), req.GetGroupKeyStr(),
 	)
@@ -4731,12 +4735,6 @@ func (r *rpcServer) InsertSupplyCommit(ctx context.Context,
 	req *unirpc.InsertSupplyCommitRequest) (
 	*unirpc.InsertSupplyCommitResponse, error) {
 
-	// Check the rate limiter to see if we need to wait at all. If not then
-	// this'll be a noop.
-	if err := r.proofQueryRateLimiter.Wait(ctx); err != nil {
-		return nil, err
-	}
-
 	groupPubKey, err := unmarshalGroupKey(
 		req.GetGroupKeyBytes(), req.GetGroupKeyStr(),
 	)

tapdb/addrs.go

@@ -990,9 +990,10 @@ func (t *TapAddressBook) QueryAddrEvents(
 	error) {
 
 	sqlQuery := AddrEventQuery{
-		StatusFrom:   int16(address.StatusTransactionDetected),
-		StatusTo:     int16(address.StatusCompleted),
-		CreatedAfter: time.Unix(0, 0).UTC(),
+		StatusFrom:    int16(address.StatusTransactionDetected),
+		StatusTo:      int16(address.StatusCompleted),
+		CreatedAfter:  time.Unix(0, 0).UTC(),
+		CreatedBefore: time.Now().UTC(),
 	}
 	if len(params.AddrTaprootOutputKey) > 0 {
 		sqlQuery.AddrTaprootKey = params.AddrTaprootOutputKey
@@ -1006,6 +1007,13 @@ func (t *TapAddressBook) QueryAddrEvents(
 	if params.CreationTimeFrom != nil && !params.CreationTimeFrom.IsZero() {
 		sqlQuery.CreatedAfter = params.CreationTimeFrom.UTC()
 	}
+	if params.CreationTimeTo != nil && !params.CreationTimeTo.IsZero() {
+		sqlQuery.CreatedBefore = params.CreationTimeTo.UTC()
+	}
+	if sqlQuery.CreatedAfter.After(sqlQuery.CreatedBefore) {
+		return nil, fmt.Errorf("created after time after " +
+			"created before time")
+	}
 
 	var (
 		readTxOpts = NewAssetStoreReadTx()

tapdb/sqlc/addrs.sql.go

@@ -226,6 +226,7 @@ WHERE addr_events.status >= @status_from
   AND addr_events.status <= @status_to
   AND COALESCE(@addr_taproot_key, addrs.taproot_output_key) = addrs.taproot_output_key
   AND addr_events.creation_time >= @created_after
+  AND addr_events.creation_time <= @created_before
 ORDER by addr_events.creation_time;
 
 -- name: QueryLastEventHeight :one