fix: change the way sigchain handles getting signedClaims when given an order (it was the wrong way around)

fix: fixed discovery test failure for updates previously discovered gestalts

Author: CDeltakai

src/nodes/NodeManager.ts

@@ -1257,12 +1257,18 @@ class NodeManager {
     return await this.withConnF(targetNodeId, ctx, async (connection) => {
       const claims: Record<ClaimId, SignedClaim> = {};
       const client = connection.getClient();
+      let claimIdEncoded: ClaimIdEncoded | undefined;
+
+      if(claimId != null){
+          claimIdEncoded = claimsUtils.encodeClaimId(claimId);
+      }else
+      {
+        claimIdEncoded = undefined;
+      }
+
       for await (const agentClaim of await client.methods.nodesClaimsGet(
         {
-          seek:
-            claimId != null
-              ? claimsUtils.encodeClaimId(claimId)
-              : ('' as ClaimIdEncoded),
+          seek: claimIdEncoded,
         },
         ctx,
       )) {

src/nodes/agent/handlers/NodesClaimsGet.ts

@@ -32,7 +32,10 @@ class NodesClaimsGet extends ServerHandler<
     const { seek, order, limit } = input;
     const { sigchain, db }: { sigchain: Sigchain; db: DB } = this.container;
 
-    const decodedClaimId = ids.decodeClaimId(seek);
+    let decodedClaimId = ids.decodeClaimId(seek);
+    if (decodedClaimId == null) {
+      decodedClaimId = undefined;
+    }
 
     yield* db.withTransactionG(async function* (tran): AsyncGenerator<
       AgentRPCResponseResult<AgentClaimMessage>

src/sigchain/Sigchain.ts

@@ -354,10 +354,10 @@ class Sigchain {
       seekOptions =
         order === 'asc'
           ? {
-              lte: [seek.toBuffer()],
+              gte: [seek.toBuffer()],
             }
           : {
-              gte: [seek.toBuffer()],
+              lte: [seek.toBuffer()],
             };
     }
     for await (const [kP, claim] of tran.iterator<Claim>(this.dbClaimsPath, {

tests/nodes/agent/handlers/nodesClaimsGet.test.ts

@@ -16,6 +16,7 @@ import * as keysUtils from '@/keys/utils';
 import * as networkUtils from '@/network/utils';
 import * as tlsTestsUtils from '../../../utils/tls';
 import * as testNodesUtils from '../../../nodes/utils';
+import { ClaimIdEncoded } from '@/ids';
 
 describe('nodesClaimsGet', () => {
   const logger = new Logger('nodesClaimsGet test', LogLevel.WARN, [
@@ -314,4 +315,63 @@ describe('nodesClaimsGet', () => {
     // Verify the array is empty
     expect(claimIds).toHaveLength(0);
   });
+
+
+  test('Should get chain data with valid seek parameter and all chain data if invalid seek', async () => {
+    const srcNodeIdEncoded = nodesUtils.encodeNodeId(keyRing.getNodeId());
+  
+    // Add 10 claims
+    for (let i = 1; i <= 5; i++) {
+      const node2 = nodesUtils.encodeNodeId(
+        testNodesUtils.generateRandomNodeId(),
+      );
+      const nodeLink = {
+        type: 'ClaimLinkNode',
+        iss: srcNodeIdEncoded,
+        sub: node2,
+      };
+      await sigchain.addClaim(nodeLink);
+    }
+    for (let i = 6; i <= 10; i++) {
+      const identityLink = {
+        type: 'ClaimLinkIdentity',
+        iss: srcNodeIdEncoded,
+        sub: encodeProviderIdentityId([
+          ('ProviderId' + i.toString()) as ProviderId,
+          ('IdentityId' + i.toString()) as IdentityId,
+        ]),
+      };
+      await sigchain.addClaim(identityLink);
+    }
+  
+    // First, if we provide an invalid seek value, we should get all claims.
+    let response = await rpcClient.methods.nodesClaimsGet({ seek: undefined });
+    const allClaimIds: ClaimIdEncoded[] = [];
+    for await (const claim of response) {
+      // We assume claimIdEncoded is defined for all returned claims.
+      allClaimIds.push(claim.claimIdEncoded!);
+    }
+    expect(allClaimIds).toHaveLength(10);
+  
+    // Now choose a seek claim.
+    const seekClaimId = allClaimIds[3];
+  
+    // Now retrieve claims starting from the seek value.
+    response = await rpcClient.methods.nodesClaimsGet({ order: 'asc', seek: seekClaimId });
+    const subsetClaimIds: string[] = [];
+    for await (const claim of response) {
+      subsetClaimIds.push(claim.claimIdEncoded!);
+    }
+  
+    // Our expectation is that the claim with the seek value is excluded
+    // and that the remaining claims match the tail of allClaimIds.
+    console.log("subsetClaimIds",subsetClaimIds);
+    console.log("allClaimIds",allClaimIds);
+    console.log("allClaimIds.slice(4)",allClaimIds.slice(3));
+    console.log("seekClaimId", seekClaimId);
+    expect(subsetClaimIds).toEqual(allClaimIds.slice(3));
+  }); 
+  
+
+
 });