@aboutcircles/sdk-rpc 0.1.28 → 0.1.30

package/dist/methods/trust.d.ts

@@ -1,5 +1,5 @@
 import type { RpcClient } from '../client.js';
-import type { Address, TrustRelation, AggregatedTrustRelation } from '@aboutcircles/sdk-types';
+import type { Address, TrustRelation, AggregatedTrustRelation, TrustNetworkSummary, AggregatedTrustRelationsResponse, ValidInvitersResponse } from '@aboutcircles/sdk-types';
 import { PagedQuery } from '../pagedQuery.js';
 /**
  * Trust relation RPC methods
@@ -49,9 +49,7 @@ export declare class TrustMethods {
     getTrustRelations(avatar: Address, limit?: number, sortOrder?: 'ASC' | 'DESC'): PagedQuery<TrustRelation>;
     /**
      * Get aggregated trust relations for an address
-     * Groups trust relations by counterpart and determines relationship type
-     *
-     * Note: This method fetches ALL trust relations for aggregation.
+     * Uses the native RPC method for efficient server-side aggregation
      *
      * @param avatar - Avatar address to query trust relations for
      * @returns Aggregated trust relations with relationship types
@@ -62,8 +60,8 @@ export declare class TrustMethods {
      *   '0xde374ece6fa50e781e81aac78e811b33d16912c7'
      * );
      * // Returns: [
-     * //   { subjectAvatar: '0x...', relation: 'mutuallyTrusts', objectAvatar: '0x...', timestamp: 123 },
-     * //   { subjectAvatar: '0x...', relation: 'trusts', objectAvatar: '0x...', timestamp: 456 }
+     * //   { subjectAvatar: '0x...', relation: 'mutuallyTrusts', objectAvatar: '0x...', timestamp: 123, expiryTime: 0, objectAvatarType: 'Human' },
+     * //   { subjectAvatar: '0x...', relation: 'trusts', objectAvatar: '0x...', timestamp: 456, expiryTime: 0, objectAvatarType: 'Group' }
      * // ]
      * ```
      */
@@ -110,5 +108,31 @@ export declare class TrustMethods {
      * ```
      */
     getMutualTrusts(avatar: Address): Promise<AggregatedTrustRelation[]>;
+    /**
+     * Get trust network summary
+     * Includes counts of direct trusts, trusted by, and mutual trusts
+     *
+     * @param avatar - Avatar address to query
+     * @param maxDepth - Maximum depth for network calculation (default: 2)
+     * @returns Trust network summary
+     */
+    getTrustNetworkSummary(avatar: Address, maxDepth?: number): Promise<TrustNetworkSummary>;
+    /**
+     * Get enriched aggregated trust relations
+     * Returns classified trust relations (mutual, trusts, trustedBy) with avatar info
+     *
+     * @param avatar - Avatar address to query
+     * @returns Enriched aggregated trust relations
+     */
+    getAggregatedTrustRelationsEnriched(avatar: Address): Promise<AggregatedTrustRelationsResponse>;
+    /**
+     * Get valid inviters for an address
+     * Returns addresses that trust the given address and have sufficient balance
+     *
+     * @param avatar - Avatar address to query
+     * @param minimumBalance - Minimum balance required (optional)
+     * @returns List of valid inviters
+     */
+    getValidInviters(avatar: Address, minimumBalance?: string): Promise<ValidInvitersResponse>;
 }
 //# sourceMappingURL=trust.d.ts.map

package/dist/methods/trust.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trust.d.ts","sourceRoot":"","sources":["../../src/methods/trust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAmD,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAEhJ,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;GAEG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC,OAAO,CAAC,sBAAsB;IAW9B;;;;;;;;;;;;;;;OAeG;IAEG,cAAc,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAQ9E;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAAiB,CACf,MAAM,EAAE,OAAO,EACf,KAAK,GAAE,MAAY,EACnB,SAAS,GAAE,KAAK,GAAG,MAAe,GACjC,UAAU,CAAC,aAAa,CAAC;IA4D5B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,2BAA2B,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAuDtF;;;;;;;;;;;;OAYG;IACG,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAOvE;;;;;;;;;;;;OAYG;IACG,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAOpE;;;;;;;;;;;;OAYG;IACG,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;CAM3E"}
+{"version":3,"file":"trust.d.ts","sourceRoot":"","sources":["../../src/methods/trust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAmD,uBAAuB,EAAE,mBAAmB,EAAE,gCAAgC,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAE9N,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;GAEG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC,OAAO,CAAC,sBAAsB;IAW9B;;;;;;;;;;;;;;;OAeG;IAEG,cAAc,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAQ9E;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAAiB,CACf,MAAM,EAAE,OAAO,EACf,KAAK,GAAE,MAAY,EACnB,SAAS,GAAE,KAAK,GAAG,MAAe,GACjC,UAAU,CAAC,aAAa,CAAC;IA4D5B;;;;;;;;;;;;;;;;;OAiBG;IACG,2BAA2B,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAYtF;;;;;;;;;;;;OAYG;IACG,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAOvE;;;;;;;;;;;;OAYG;IACG,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAOpE;;;;;;;;;;;;OAYG;IACG,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAO1E;;;;;;;OAOG;IACG,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAE,MAAU,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAOjG;;;;;;OAMG;IACG,mCAAmC,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,gCAAgC,CAAC;IAMrG;;;;;;;OAOG;IACG,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAOjG"}

package/dist/methods/trust.js

@@ -118,9 +118,7 @@ export class TrustMethods {
     }
     /**
      * Get aggregated trust relations for an address
-     * Groups trust relations by counterpart and determines relationship type
-     *
-     * Note: This method fetches ALL trust relations for aggregation.
+     * Uses the native RPC method for efficient server-side aggregation
      *
      * @param avatar - Avatar address to query trust relations for
      * @returns Aggregated trust relations with relationship types
@@ -131,58 +129,15 @@ export class TrustMethods {
      *   '0xde374ece6fa50e781e81aac78e811b33d16912c7'
      * );
      * // Returns: [
-     * //   { subjectAvatar: '0x...', relation: 'mutuallyTrusts', objectAvatar: '0x...', timestamp: 123 },
-     * //   { subjectAvatar: '0x...', relation: 'trusts', objectAvatar: '0x...', timestamp: 456 }
+     * //   { subjectAvatar: '0x...', relation: 'mutuallyTrusts', objectAvatar: '0x...', timestamp: 123, expiryTime: 0, objectAvatarType: 'Human' },
+     * //   { subjectAvatar: '0x...', relation: 'trusts', objectAvatar: '0x...', timestamp: 456, expiryTime: 0, objectAvatarType: 'Group' }
      * // ]
      * ```
      */
     async getAggregatedTrustRelations(avatar) {
         const normalized = normalizeAddress(avatar);
-        // Fetch all trust relations by paginating
-        const query = this.getTrustRelations(normalized, 1000);
-        const trustListRows = [];
-        while (await query.queryNextPage()) {
-            trustListRows.push(...query.currentPage.results);
-            if (!query.currentPage.hasMore)
-                break;
-        }
-        // Group trust list rows by counterpart avatar
-        const trustBucket = {};
-        trustListRows.forEach((row) => {
-            // Normalize addresses for comparison (both are already checksummed from getTrustRelations)
-            const trusterNorm = normalizeAddress(row.truster);
-            const trusteeNorm = normalizeAddress(row.trustee);
-            const counterpart = trusterNorm !== normalized ? row.truster : row.trustee;
-            if (!trustBucket[counterpart]) {
-                trustBucket[counterpart] = [];
-            }
-            trustBucket[counterpart].push(row);
-        });
-        // Determine trust relations
-        const result = Object.entries(trustBucket)
-            .filter(([address]) => normalizeAddress(address) !== normalized)
-            .map(([address, rows]) => {
-            const maxTimestamp = Math.max(...rows.map((o) => o.timestamp));
-            let relation;
-            if (rows.length === 2) {
-                relation = 'mutuallyTrusts';
-            }
-            else if (normalizeAddress(rows[0]?.trustee) === normalized) {
-                relation = 'trustedBy';
-            }
-            else if (normalizeAddress(rows[0]?.truster) === normalized) {
-                relation = 'trusts';
-            }
-            else {
-                throw new Error(`Unexpected trust list row. Couldn't determine trust relation.`);
-            }
-            return {
-                subjectAvatar: normalized,
-                relation,
-                objectAvatar: address,
-                timestamp: maxTimestamp,
-            };
-        });
+        // Use native RPC method for server-side aggregation
+        const result = await this.client.call('circles_getAggregatedTrustRelations', [normalized]);
         return checksumAddresses(result);
     }
     /**
@@ -242,4 +197,45 @@ export class TrustMethods {
         const filtered = relations.filter((r) => r.relation === 'mutuallyTrusts');
         return checksumAddresses(filtered);
     }
+    /**
+     * Get trust network summary
+     * Includes counts of direct trusts, trusted by, and mutual trusts
+     *
+     * @param avatar - Avatar address to query
+     * @param maxDepth - Maximum depth for network calculation (default: 2)
+     * @returns Trust network summary
+     */
+    async getTrustNetworkSummary(avatar, maxDepth = 2) {
+        return this.client.call('circles_getTrustNetworkSummary', [
+            normalizeAddress(avatar),
+            maxDepth
+        ]);
+    }
+    /**
+     * Get enriched aggregated trust relations
+     * Returns classified trust relations (mutual, trusts, trustedBy) with avatar info
+     *
+     * @param avatar - Avatar address to query
+     * @returns Enriched aggregated trust relations
+     */
+    async getAggregatedTrustRelationsEnriched(avatar) {
+        return this.client.call('circles_getAggregatedTrustRelationsEnriched', [
+            normalizeAddress(avatar)
+        ]);
+    }
+    /**
+     * Get valid inviters for an address
+     * Returns addresses that trust the given address and have sufficient balance
+     *
+     * @param avatar - Avatar address to query
+     * @param minimumBalance - Minimum balance required (optional)
+     * @returns List of valid inviters
+     */
+    async getValidInviters(avatar, minimumBalance) {
+        const params = [normalizeAddress(avatar)];
+        if (minimumBalance) {
+            params.push(minimumBalance);
+        }
+        return this.client.call('circles_getValidInviters', params);
+    }
 }

package/dist/pagedQuery.d.ts

@@ -2,14 +2,13 @@ import type { RpcClient } from './client.js';
 import type { PagedQueryParams, OrderBy } from '@aboutcircles/sdk-types';
 import type { CursorColumn, FlexiblePagedResult } from './types.js';
 /**
- * A class for querying Circles RPC nodes with cursor-based pagination.
- * Supports both event-based pagination (default) and custom cursor pagination (for view tables).
+ * A class for querying Circles RPC nodes with server-side cursor-based pagination.
+ * Uses circles_paginated_query which returns {columns, rows, hasMore, nextCursor}.
  *
  * @typeParam TRow The type of the rows returned by the query.
  *
  * @example
  * ```typescript
- * // Event-based pagination
  * const query = new PagedQuery<GroupMembershipRow>(rpc.client, {
  *   namespace: 'V_CrcV2',
  *   table: 'GroupMemberships',
@@ -19,16 +18,10 @@ import type { CursorColumn, FlexiblePagedResult } from './types.js';
  *   limit: 100
  * });
  *
- * // Custom cursor pagination (for view tables)
- * const viewQuery = new PagedQuery<GroupTokenHolderRow>(rpc.client, {
- *   namespace: 'V_CrcV2',
- *   table: 'GroupTokenHoldersBalance',
- *   sortOrder: 'ASC',
- *   columns: ['group', 'holder', 'totalBalance'],
- *   cursorColumns: [{ name: 'holder', sortOrder: 'ASC' }],
- *   filter: [{ Type: 'FilterPredicate', FilterType: 'Equals', Column: 'group', Value: '0x...' }],
- *   limit: 100
- * });
+ * while (await query.queryNextPage()) {
+ *   console.log(query.currentPage!.results);
+ *   if (!query.currentPage!.hasMore) break;
+ * }
  * ```
  */
 export declare class PagedQuery<TRow = any> {
@@ -48,52 +41,17 @@ export declare class PagedQuery<TRow = any> {
      * Builds cursor columns for event-based tables
      */
     private buildEventCursorColumns;
-    /**
-     * Transforms a cursor value for use in query filters
-     */
-    private transformCursorValue;
-    /**
-     * Creates an equality predicate for a cursor column
-     */
-    private createEqualityPredicate;
-    /**
-     * Creates a comparison predicate for a cursor column (> or <)
-     */
-    private createComparisonPredicate;
-    /**
-     * Builds cursor filter for pagination using composite cursor columns.
-     *
-     * Creates an OR conjunction of predicates for each cursor level:
-     * - First level: col1 > cursor.col1
-     * - Second level: col1 = cursor.col1 AND col2 > cursor.col2
-     * - Third level: col1 = cursor.col1 AND col2 = cursor.col2 AND col3 > cursor.col3
-     *
-     * This ensures correct pagination across all cursor columns.
-     */
-    private buildCursorFilter;
     /**
      * Builds the order by clause.
      * If orderColumns are provided, uses those. Otherwise builds from cursor columns.
      */
     private buildOrderBy;
-    /**
-     * Combines base filters with cursor filter
-     */
-    private combineFilters;
     /**
      * Converts query response rows to typed objects
      */
     private rowsToObjects;
     /**
-     * Extracts cursor values from a row
-     */
-    private rowToCursor;
-    /**
-     * Gets first and last cursors from result set
-     */
-    private getCursors;
-    /**
-     * Queries the next page of results.
+     * Queries the next page of results using server-side cursor pagination.
      *
      * @returns True if results were found, false otherwise
      */

package/dist/pagedQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pagedQuery.d.ts","sourceRoot":"","sources":["../src/pagedQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EACV,gBAAgB,EAEhB,OAAO,EAGR,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAWpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,UAAU,CAAC,IAAI,GAAG,GAAG;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAIrB;IACF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAqB;IACrD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiB;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAY;IAE1C,IAAI,WAAW,IAAI,mBAAmB,CAAC,IAAI,CAAC,GAAG,SAAS,CAEvD;IAED,OAAO,CAAC,YAAY,CAAC,CAA4B;gBAG/C,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,gBAAgB,GAAG;QACzB,aAAa,CAAC,EAAE,YAAY,EAAE,CAAC;QAC/B,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC;QACzB,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAA;KACpC,EACD,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI;IAWrC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAc/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAM5B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAS/B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAWjC;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAgDzB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;IACH,OAAO,CAAC,cAAc;IAYtB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;OAEG;IACH,OAAO,CAAC,WAAW;IAUnB;;OAEG;IACH,OAAO,CAAC,UAAU;IASlB;;;;OAIG;IACU,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IA8B9C;;OAEG;IACI,KAAK,IAAI,IAAI;CAGrB"}
+{"version":3,"file":"pagedQuery.d.ts","sourceRoot":"","sources":["../src/pagedQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EACV,gBAAgB,EAChB,OAAO,EAGR,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAWpE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU,CAAC,IAAI,GAAG,GAAG;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAIrB;IACF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAqB;IACrD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiB;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAY;IAE1C,IAAI,WAAW,IAAI,mBAAmB,CAAC,IAAI,CAAC,GAAG,SAAS,CAEvD;IAED,OAAO,CAAC,YAAY,CAAC,CAA4B;gBAG/C,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,gBAAgB,GAAG;QACzB,aAAa,CAAC,EAAE,YAAY,EAAE,CAAC;QAC/B,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC;QACzB,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAA;KACpC,EACD,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI;IAWrC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;;OAGG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;;OAIG;IACU,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IAkC9C;;OAEG;IACI,KAAK,IAAI,IAAI;CAGrB"}

package/dist/pagedQuery.js

@@ -1,5 +1,5 @@
 /**
- * Cursor configuration for different table types
+ * Default cursor columns for event-based tables (blockNumber, transactionIndex, logIndex DESC)
  */
 const EVENT_CURSOR_COLUMNS = [
     { name: 'blockNumber', sortOrder: 'DESC' },
@@ -7,14 +7,13 @@ const EVENT_CURSOR_COLUMNS = [
     { name: 'logIndex', sortOrder: 'DESC' },
 ];
 /**
- * A class for querying Circles RPC nodes with cursor-based pagination.
- * Supports both event-based pagination (default) and custom cursor pagination (for view tables).
+ * A class for querying Circles RPC nodes with server-side cursor-based pagination.
+ * Uses circles_paginated_query which returns {columns, rows, hasMore, nextCursor}.
  *
  * @typeParam TRow The type of the rows returned by the query.
  *
  * @example
  * ```typescript
- * // Event-based pagination
  * const query = new PagedQuery<GroupMembershipRow>(rpc.client, {
  *   namespace: 'V_CrcV2',
  *   table: 'GroupMemberships',
@@ -24,16 +23,10 @@ const EVENT_CURSOR_COLUMNS = [
  *   limit: 100
  * });
  *
- * // Custom cursor pagination (for view tables)
- * const viewQuery = new PagedQuery<GroupTokenHolderRow>(rpc.client, {
- *   namespace: 'V_CrcV2',
- *   table: 'GroupTokenHoldersBalance',
- *   sortOrder: 'ASC',
- *   columns: ['group', 'holder', 'totalBalance'],
- *   cursorColumns: [{ name: 'holder', sortOrder: 'ASC' }],
- *   filter: [{ Type: 'FilterPredicate', FilterType: 'Equals', Column: 'group', Value: '0x...' }],
- *   limit: 100
- * });
+ * while (await query.queryNextPage()) {
+ *   console.log(query.currentPage!.results);
+ *   if (!query.currentPage!.hasMore) break;
+ * }
  * ```
  */
 export class PagedQuery {
@@ -51,7 +44,7 @@ export class PagedQuery {
         this.params = params;
         this.rowTransformer = rowTransformer || params.rowTransformer;
         this.orderColumns = params.orderColumns;
-        // Determine cursor columns based on table type
+        // Cursor columns only used for buildOrderBy() — actual pagination is server-side
         this.cursorColumns = params.cursorColumns || this.buildEventCursorColumns();
     }
     /**
@@ -62,96 +55,11 @@ export class PagedQuery {
             ...col,
             sortOrder: this.params.sortOrder
         }));
-        // Add batchIndex for TransferBatch table
         if (this.params.table === 'TransferBatch') {
             columns.push({ name: 'batchIndex', sortOrder: this.params.sortOrder });
         }
         return columns;
     }
-    /**
-     * Transforms a cursor value for use in query filters
-     */
-    transformCursorValue(value, transformer) {
-        if (transformer)
-            return transformer(value);
-        if (typeof value === 'bigint')
-            return value.toString();
-        return value;
-    }
-    /**
-     * Creates an equality predicate for a cursor column
-     */
-    createEqualityPredicate(column, value) {
-        return {
-            Type: 'FilterPredicate',
-            FilterType: 'Equals',
-            Column: column.name,
-            Value: this.transformCursorValue(value, column.toValue),
-        };
-    }
-    /**
-     * Creates a comparison predicate for a cursor column (> or <)
-     */
-    createComparisonPredicate(column, value) {
-        const filterType = column.sortOrder === 'ASC' ? 'GreaterThan' : 'LessThan';
-        return {
-            Type: 'FilterPredicate',
-            FilterType: filterType,
-            Column: column.name,
-            Value: this.transformCursorValue(value, column.toValue),
-        };
-    }
-    /**
-     * Builds cursor filter for pagination using composite cursor columns.
-     *
-     * Creates an OR conjunction of predicates for each cursor level:
-     * - First level: col1 > cursor.col1
-     * - Second level: col1 = cursor.col1 AND col2 > cursor.col2
-     * - Third level: col1 = cursor.col1 AND col2 = cursor.col2 AND col3 > cursor.col3
-     *
-     * This ensures correct pagination across all cursor columns.
-     */
-    buildCursorFilter(cursor) {
-        if (!cursor)
-            return [];
-        const orPredicates = [];
-        for (let level = 0; level < this.cursorColumns.length; level++) {
-            const currentColumn = this.cursorColumns[level];
-            const cursorValue = cursor[currentColumn.name];
-            if (cursorValue === undefined)
-                continue;
-            if (level === 0) {
-                // First level: simple comparison (col > value)
-                orPredicates.push(this.createComparisonPredicate(currentColumn, cursorValue));
-            }
-            else {
-                // Subsequent levels: equality for all previous + comparison for current
-                const andPredicates = [];
-                // Add equality predicates for all previous columns
-                for (let prevLevel = 0; prevLevel < level; prevLevel++) {
-                    const prevColumn = this.cursorColumns[prevLevel];
-                    const prevValue = cursor[prevColumn.name];
-                    if (prevValue !== undefined) {
-                        andPredicates.push(this.createEqualityPredicate(prevColumn, prevValue));
-                    }
-                }
-                // Add comparison predicate for current column
-                andPredicates.push(this.createComparisonPredicate(currentColumn, cursorValue));
-                orPredicates.push({
-                    Type: 'Conjunction',
-                    ConjunctionType: 'And',
-                    Predicates: andPredicates,
-                });
-            }
-        }
-        if (orPredicates.length === 0)
-            return [];
-        return [{
-                Type: 'Conjunction',
-                ConjunctionType: 'Or',
-                Predicates: orPredicates,
-            }];
-    }
     /**
      * Builds the order by clause.
      * If orderColumns are provided, uses those. Otherwise builds from cursor columns.
@@ -165,22 +73,6 @@ export class PagedQuery {
             SortOrder: col.sortOrder,
         }));
     }
-    /**
-     * Combines base filters with cursor filter
-     */
-    combineFilters(baseFilters, cursorFilter) {
-        if (!baseFilters?.length && !cursorFilter?.length)
-            return [];
-        if (!baseFilters?.length)
-            return cursorFilter || [];
-        if (!cursorFilter?.length)
-            return baseFilters;
-        return [{
-                Type: 'Conjunction',
-                ConjunctionType: 'And',
-                Predicates: [...baseFilters, ...cursorFilter],
-            }];
-    }
     /**
      * Converts query response rows to typed objects
      */
@@ -195,52 +87,31 @@ export class PagedQuery {
         });
     }
     /**
-     * Extracts cursor values from a row
-     */
-    rowToCursor(row) {
-        const cursor = {};
-        for (const column of this.cursorColumns) {
-            cursor[column.name] = row[column.name];
-        }
-        return cursor;
-    }
-    /**
-     * Gets first and last cursors from result set
-     */
-    getCursors(results) {
-        if (results.length === 0)
-            return {};
-        return {
-            first: this.rowToCursor(results[0]),
-            last: this.rowToCursor(results[results.length - 1]),
-        };
-    }
-    /**
-     * Queries the next page of results.
+     * Queries the next page of results using server-side cursor pagination.
      *
      * @returns True if results were found, false otherwise
      */
     async queryNextPage() {
-        const cursorFilter = this.buildCursorFilter(this._currentPage?.lastCursor);
-        const combinedFilter = this.combineFilters(this.params.filter, cursorFilter);
         const queryParams = {
             Namespace: this.params.namespace,
             Table: this.params.table,
             Columns: this.params.columns,
-            Filter: combinedFilter,
+            Filter: this.params.filter || [],
             Order: this.buildOrderBy(),
             Limit: this.params.limit,
         };
-        const response = await this.client.call('circles_query', [queryParams]);
+        // Pass [queryParams] or [queryParams, nextCursor] to circles_paginated_query
+        const rpcParams = this._currentPage?.nextCursor
+            ? [queryParams, this._currentPage.nextCursor]
+            : [queryParams];
+        const response = await this.client.call('circles_paginated_query', rpcParams);
         const results = this.rowsToObjects(response);
-        const cursors = this.getCursors(results);
         this._currentPage = {
             limit: this.params.limit,
             size: results.length,
-            firstCursor: cursors.first,
-            lastCursor: cursors.last,
             sortOrder: this.params.sortOrder,
-            hasMore: results.length === this.params.limit,
+            hasMore: response.hasMore,
+            nextCursor: response.nextCursor ?? undefined,
             results,
         };
         return results.length > 0;

package/dist/rpc.d.ts

@@ -1,5 +1,5 @@
 import { RpcClient } from './client.js';
-import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMethods, ProfileMethods, TokenMethods, InvitationMethods, TransactionMethods, GroupMethods } from './methods/index.js';
+import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMethods, ProfileMethods, TokenMethods, InvitationMethods, TransactionMethods, GroupMethods, SdkMethods } from './methods/index.js';
 /**
  * Main RPC class for Circles protocol RPC interactions
  *
@@ -12,7 +12,7 @@ import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMe
  * const rpc = new CirclesRpc();
  *
  * // Use custom RPC endpoint
- * const rpc = new CirclesRpc('https://rpc.circlesubi.network/');
+ * const rpc = new CirclesRpc('https://rpc.aboutcircles.com/');
  *
  * // Find a path
  * const path = await rpc.pathfinder.findPath({
@@ -32,6 +32,9 @@ import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMe
  *
  * // Get profile
  * const profile = await rpc.profile.getProfileByAddress('0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7');
+ *
+ * // Get consolidated profile view (Phase 3 SDK enablement)
+ * const profileView = await rpc.sdk.getProfileView('0xde374ece6fa50e781e81aac78e811b33d16912c7');
  * ```
  */
 export declare class CirclesRpc {
@@ -46,10 +49,11 @@ export declare class CirclesRpc {
     private _invitation?;
     private _transaction?;
     private _group?;
+    private _sdk?;
     /**
      * Create a new CirclesRpc instance
      *
-     * @param rpcUrl RPC URL to use (defaults to https://rpc.circlesubi.network/)
+     * @param rpcUrl RPC URL to use (defaults to https://rpc.aboutcircles.com/)
      */
     constructor(rpcUrl?: string);
     get pathfinder(): PathfinderMethods;
@@ -62,6 +66,7 @@ export declare class CirclesRpc {
     get invitation(): InvitationMethods;
     get transaction(): TransactionMethods;
     get group(): GroupMethods;
+    get sdk(): SdkMethods;
     /**
      * Update the RPC URL
      */

package/dist/rpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACb,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,UAAU;IACrB,SAAgB,MAAM,EAAE,SAAS,CAAC;IAElC,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,MAAM,CAAC,CAAe;IAC9B,OAAO,CAAC,MAAM,CAAC,CAAe;IAC9B,OAAO,CAAC,QAAQ,CAAC,CAAiB;IAClC,OAAO,CAAC,OAAO,CAAC,CAAgB;IAChC,OAAO,CAAC,QAAQ,CAAC,CAAiB;IAClC,OAAO,CAAC,MAAM,CAAC,CAAe;IAC9B,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,YAAY,CAAC,CAAqB;IAC1C,OAAO,CAAC,MAAM,CAAC,CAAe;IAE9B;;;;OAIG;gBACS,MAAM,GAAE,MAA0C;IAI9D,IAAI,UAAU,IAAI,iBAAiB,CAKlC;IAED,IAAI,KAAK,IAAI,YAAY,CAKxB;IAED,IAAI,KAAK,IAAI,YAAY,CAKxB;IAED,IAAI,OAAO,IAAI,cAAc,CAK5B;IAED,IAAI,MAAM,IAAI,aAAa,CAK1B;IAED,IAAI,OAAO,IAAI,cAAc,CAK5B;IAED,IAAI,KAAK,IAAI,YAAY,CAKxB;IAED,IAAI,UAAU,IAAI,iBAAiB,CAKlC;IAED,IAAI,WAAW,IAAI,kBAAkB,CAKpC;IAED,IAAI,KAAK,IAAI,YAAY,CAKxB;IAED;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B;;OAEG;IACH,SAAS,IAAI,MAAM;CAGpB"}
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACX,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,UAAU;IACrB,SAAgB,MAAM,EAAE,SAAS,CAAC;IAElC,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,MAAM,CAAC,CAAe;IAC9B,OAAO,CAAC,MAAM,CAAC,CAAe;IAC9B,OAAO,CAAC,QAAQ,CAAC,CAAiB;IAClC,OAAO,CAAC,OAAO,CAAC,CAAgB;IAChC,OAAO,CAAC,QAAQ,CAAC,CAAiB;IAClC,OAAO,CAAC,MAAM,CAAC,CAAe;IAC9B,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,YAAY,CAAC,CAAqB;IAC1C,OAAO,CAAC,MAAM,CAAC,CAAe;IAC9B,OAAO,CAAC,IAAI,CAAC,CAAa;IAE1B;;;;OAIG;gBACS,MAAM,GAAE,MAAwC;IAI5D,IAAI,UAAU,IAAI,iBAAiB,CAKlC;IAED,IAAI,KAAK,IAAI,YAAY,CAKxB;IAED,IAAI,KAAK,IAAI,YAAY,CAKxB;IAED,IAAI,OAAO,IAAI,cAAc,CAK5B;IAED,IAAI,MAAM,IAAI,aAAa,CAK1B;IAED,IAAI,OAAO,IAAI,cAAc,CAK5B;IAED,IAAI,KAAK,IAAI,YAAY,CAKxB;IAED,IAAI,UAAU,IAAI,iBAAiB,CAKlC;IAED,IAAI,WAAW,IAAI,kBAAkB,CAKpC;IAED,IAAI,KAAK,IAAI,YAAY,CAKxB;IAED,IAAI,GAAG,IAAI,UAAU,CAKpB;IAED;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B;;OAEG;IACH,SAAS,IAAI,MAAM;CAGpB"}

package/dist/rpc.js

@@ -1,5 +1,5 @@
 import { RpcClient } from './client.js';
-import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMethods, ProfileMethods, TokenMethods, InvitationMethods, TransactionMethods, GroupMethods, } from './methods/index.js';
+import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMethods, ProfileMethods, TokenMethods, InvitationMethods, TransactionMethods, GroupMethods, SdkMethods, } from './methods/index.js';
 /**
  * Main RPC class for Circles protocol RPC interactions
  *
@@ -12,7 +12,7 @@ import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMe
  * const rpc = new CirclesRpc();
  *
  * // Use custom RPC endpoint
- * const rpc = new CirclesRpc('https://rpc.circlesubi.network/');
+ * const rpc = new CirclesRpc('https://rpc.aboutcircles.com/');
  *
  * // Find a path
  * const path = await rpc.pathfinder.findPath({
@@ -32,6 +32,9 @@ import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMe
  *
  * // Get profile
  * const profile = await rpc.profile.getProfileByAddress('0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7');
+ *
+ * // Get consolidated profile view (Phase 3 SDK enablement)
+ * const profileView = await rpc.sdk.getProfileView('0xde374ece6fa50e781e81aac78e811b33d16912c7');
  * ```
  */
 export class CirclesRpc {
@@ -46,12 +49,13 @@ export class CirclesRpc {
     _invitation;
     _transaction;
     _group;
+    _sdk;
     /**
      * Create a new CirclesRpc instance
      *
-     * @param rpcUrl RPC URL to use (defaults to https://rpc.circlesubi.network/)
+     * @param rpcUrl RPC URL to use (defaults to https://rpc.aboutcircles.com/)
      */
-    constructor(rpcUrl = 'https://rpc.circlesubi.network/') {
+    constructor(rpcUrl = 'https://rpc.aboutcircles.com/') {
         this.client = new RpcClient(rpcUrl);
     }
     get pathfinder() {
@@ -114,6 +118,12 @@ export class CirclesRpc {
         }
         return this._group;
     }
+    get sdk() {
+        if (!this._sdk) {
+            this._sdk = new SdkMethods(this.client);
+        }
+        return this._sdk;
+    }
     /**
      * Update the RPC URL
      */

package/dist/types.d.ts

@@ -60,23 +60,22 @@ export interface GroupTokenHolderRow {
     fractionOwnership: number;
 }
 /**
- * Configuration for a cursor column in pagination
+ * Configuration for a cursor column in pagination.
+ * Used only for buildOrderBy() — cursor columns define the sort order.
  */
 export interface CursorColumn {
     name: string;
     sortOrder: 'ASC' | 'DESC';
-    toValue?: (value: any) => string | number | boolean;
 }
 /**
- * Flexible paged result that works with both event-based and custom cursors
+ * Flexible paged result using server-side opaque cursors
  */
 export interface FlexiblePagedResult<TRow> {
     limit: number;
     size: number;
-    firstCursor?: Record<string, any>;
-    lastCursor?: Record<string, any>;
     sortOrder: 'ASC' | 'DESC';
     hasMore: boolean;
+    nextCursor?: string;
     results: TRow[];
 }
 //# sourceMappingURL=types.d.ts.map