@aboutcircles/sdk-rpc 0.1.27 → 0.1.29

package/dist/methods/sdk.d.ts

@@ -0,0 +1,142 @@
+import type { Address, ProfileView, TrustNetworkSummary, AggregatedTrustRelation, ValidInvitersResponse, PagedResponse, EnrichedTransaction, ProfileSearchResponse } from '@aboutcircles/sdk-types';
+import type { RpcClient } from '../client';
+/**
+ * SDK Enablement RPC methods
+ * These methods reduce SDK round-trips by consolidating common multi-call patterns
+ */
+export declare class SdkMethods {
+    private client;
+    constructor(client: RpcClient);
+    /**
+     * Get a complete profile view combining avatar info, profile data, trust stats, and balances
+     *
+     * Replaces 6-7 separate RPC calls:
+     * - circles_getAvatarInfo
+     * - circles_getProfileByAddress
+     * - circles_getTrustRelations
+     * - circles_getTotalBalance (v1)
+     * - circlesV2_getTotalBalance (v2)
+     *
+     * @param address - Avatar address to query
+     * @returns Consolidated profile view with all data
+     *
+     * @example
+     * ```typescript
+     * const profileView = await rpc.sdk.getProfileView('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     * console.log(`${profileView.profile?.name} has ${profileView.trustStats.trustsCount} trusts`);
+     * console.log(`V2 Balance: ${profileView.v2Balance}`);
+     * ```
+     */
+    getProfileView(address: Address): Promise<ProfileView>;
+    /**
+     * Get aggregated trust network summary including mutual trusts and network reach
+     *
+     * Server-side aggregation reduces client-side processing and provides ready-to-display statistics.
+     * Network reach = (trusts ∪ trustedBy).count = trustsCount + trustedByCount - mutualTrustsCount
+     *
+     * @param address - Avatar address to query
+     * @param maxDepth - Maximum network depth to analyze (default: 2)
+     * @returns Trust network summary with aggregated metrics
+     *
+     * @example
+     * ```typescript
+     * const summary = await rpc.sdk.getTrustNetworkSummary('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     * console.log(`Network reach: ${summary.networkReach}`);
+     * console.log(`Mutual trusts: ${summary.mutualTrustsCount}`);
+     * ```
+     */
+    getTrustNetworkSummary(address: Address, maxDepth?: number): Promise<TrustNetworkSummary>;
+    /**
+     * Get trust relations categorized by type (mutual, one-way trusts, one-way trusted-by)
+     *
+     * Replaces client-side categorization + multiple getAvatarInfo calls.
+     * Returns relationships organized for easy UI rendering (different icons/colors per type).
+     *
+     * @param address - Avatar address to query
+     * @returns Trust relations categorized with enriched avatar info
+     *
+     * @example
+     * ```typescript
+     * const relations = await rpc.sdk.getAggregatedTrustRelations('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     * // Returns flat array: [{subjectAvatar, relation, objectAvatar, ...}]
+     * const mutual = relations.filter(r => r.relation === 'mutuallyTrusts');
+     * console.log(`Mutual trusts: ${mutual.length}`);
+     * ```
+     */
+    getAggregatedTrustRelations(address: Address): Promise<AggregatedTrustRelation[]>;
+    /**
+     * Get list of addresses that trust you AND have sufficient balance to invite
+     *
+     * Useful for invitation flows and invitation escrow scenarios.
+     * Server-side filtering reduces data transfer and client-side processing.
+     *
+     * @param address - Avatar address to query
+     * @param minimumBalance - Optional minimum balance threshold (as TimeCircles string)
+     * @returns List of valid inviters with balances and avatar info
+     *
+     * @example
+     * ```typescript
+     * // Find all potential inviters
+     * const inviters = await rpc.sdk.getValidInviters('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     *
+     * // Find inviters with at least 50 CRC balance
+     * const richInviters = await rpc.sdk.getValidInviters(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   '50.0'
+     * );
+     * ```
+     */
+    getValidInviters(address: Address, minimumBalance?: string): Promise<ValidInvitersResponse>;
+    /**
+     * Get transaction history with enriched participant profiles and metadata
+     *
+     * Replaces circles_events + multiple getProfileByAddress calls + client-side event processing.
+     * Returns transaction history ready for UI display with participant names and avatars.
+     *
+     * @param address - Avatar address to query
+     * @param fromBlock - Starting block number
+     * @param toBlock - Optional ending block number (null for latest)
+     * @param limit - Maximum number of transactions (default: 50)
+     * @returns Enriched transaction history with participant profiles
+     *
+     * @example
+     * ```typescript
+     * const history = await rpc.sdk.getTransactionHistoryEnriched(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   30282299,
+     *   null,
+     *   20
+     * );
+     *
+     * for (const tx of history.results) {
+     *   console.log(`Tx: ${tx.transactionHash}, event: ${JSON.stringify(tx.event)}`);
+     *   // Access participant profiles via tx.participants[address]
+     * }
+     * ```
+     */
+    getTransactionHistoryEnriched(address: Address, fromBlock?: number, toBlock?: number | null, limit?: number, cursor?: string | null): Promise<PagedResponse<EnrichedTransaction>>;
+    /**
+     * Unified search across profiles by address prefix OR name/description text
+     *
+     * Combines address lookup and full-text search in a single endpoint.
+     * Automatically detects search type based on query format (0x prefix = address search).
+     *
+     * @param query - Search query (address prefix or name/description text)
+     * @param limit - Maximum number of results (default: 20)
+     * @param cursor - Pagination cursor from previous response (null for first page)
+     * @param types - Optional array of avatar types to filter by
+     * @returns Unified search results with profiles
+     *
+     * @example
+     * ```typescript
+     * // Search by name
+     * const byName = await rpc.sdk.searchProfileByAddressOrName('Alice');
+     *
+     * // Paginate through results
+     * const page1 = await rpc.sdk.searchProfileByAddressOrName('developer', 10);
+     * const page2 = await rpc.sdk.searchProfileByAddressOrName('developer', 10, page1.nextCursor);
+     * ```
+     */
+    searchProfileByAddressOrName(query: string, limit?: number, cursor?: string | null, types?: string[]): Promise<ProfileSearchResponse>;
+}
+//# sourceMappingURL=sdk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../src/methods/sdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,WAAW,EACX,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,aAAa,EACb,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C;;;GAGG;AACH,qBAAa,UAAU;IACT,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC;IAQ5D;;;;;;;;;;;;;;;;OAgBG;IACG,sBAAsB,CAC1B,OAAO,EAAE,OAAO,EAChB,QAAQ,GAAE,MAAU,GACnB,OAAO,CAAC,mBAAmB,CAAC;IAQ/B;;;;;;;;;;;;;;;;OAgBG;IACG,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAQvF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,gBAAgB,CACpB,OAAO,EAAE,OAAO,EAChB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,qBAAqB,CAAC;IAUjC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,6BAA6B,CACjC,OAAO,EAAE,OAAO,EAChB,SAAS,GAAE,MAAU,EACrB,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,KAAK,GAAE,MAAW,EAClB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;IAc9C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,4BAA4B,CAChC,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAW,EAClB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,KAAK,CAAC,EAAE,MAAM,EAAE,GACf,OAAO,CAAC,qBAAqB,CAAC;CAMlC"}

package/dist/methods/sdk.js

@@ -0,0 +1,165 @@
+import { normalizeAddress, checksumAddresses } from '../utils';
+/**
+ * SDK Enablement RPC methods
+ * These methods reduce SDK round-trips by consolidating common multi-call patterns
+ */
+export class SdkMethods {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a complete profile view combining avatar info, profile data, trust stats, and balances
+     *
+     * Replaces 6-7 separate RPC calls:
+     * - circles_getAvatarInfo
+     * - circles_getProfileByAddress
+     * - circles_getTrustRelations
+     * - circles_getTotalBalance (v1)
+     * - circlesV2_getTotalBalance (v2)
+     *
+     * @param address - Avatar address to query
+     * @returns Consolidated profile view with all data
+     *
+     * @example
+     * ```typescript
+     * const profileView = await rpc.sdk.getProfileView('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     * console.log(`${profileView.profile?.name} has ${profileView.trustStats.trustsCount} trusts`);
+     * console.log(`V2 Balance: ${profileView.v2Balance}`);
+     * ```
+     */
+    async getProfileView(address) {
+        const normalizedAddress = normalizeAddress(address);
+        return this.client.call('circles_getProfileView', [normalizedAddress]);
+    }
+    /**
+     * Get aggregated trust network summary including mutual trusts and network reach
+     *
+     * Server-side aggregation reduces client-side processing and provides ready-to-display statistics.
+     * Network reach = (trusts ∪ trustedBy).count = trustsCount + trustedByCount - mutualTrustsCount
+     *
+     * @param address - Avatar address to query
+     * @param maxDepth - Maximum network depth to analyze (default: 2)
+     * @returns Trust network summary with aggregated metrics
+     *
+     * @example
+     * ```typescript
+     * const summary = await rpc.sdk.getTrustNetworkSummary('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     * console.log(`Network reach: ${summary.networkReach}`);
+     * console.log(`Mutual trusts: ${summary.mutualTrustsCount}`);
+     * ```
+     */
+    async getTrustNetworkSummary(address, maxDepth = 2) {
+        const normalizedAddress = normalizeAddress(address);
+        return this.client.call('circles_getTrustNetworkSummary', [normalizedAddress, maxDepth]);
+    }
+    /**
+     * Get trust relations categorized by type (mutual, one-way trusts, one-way trusted-by)
+     *
+     * Replaces client-side categorization + multiple getAvatarInfo calls.
+     * Returns relationships organized for easy UI rendering (different icons/colors per type).
+     *
+     * @param address - Avatar address to query
+     * @returns Trust relations categorized with enriched avatar info
+     *
+     * @example
+     * ```typescript
+     * const relations = await rpc.sdk.getAggregatedTrustRelations('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     * // Returns flat array: [{subjectAvatar, relation, objectAvatar, ...}]
+     * const mutual = relations.filter(r => r.relation === 'mutuallyTrusts');
+     * console.log(`Mutual trusts: ${mutual.length}`);
+     * ```
+     */
+    async getAggregatedTrustRelations(address) {
+        const normalizedAddress = normalizeAddress(address);
+        return this.client.call('circles_getAggregatedTrustRelations', [normalizedAddress]);
+    }
+    /**
+     * Get list of addresses that trust you AND have sufficient balance to invite
+     *
+     * Useful for invitation flows and invitation escrow scenarios.
+     * Server-side filtering reduces data transfer and client-side processing.
+     *
+     * @param address - Avatar address to query
+     * @param minimumBalance - Optional minimum balance threshold (as TimeCircles string)
+     * @returns List of valid inviters with balances and avatar info
+     *
+     * @example
+     * ```typescript
+     * // Find all potential inviters
+     * const inviters = await rpc.sdk.getValidInviters('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     *
+     * // Find inviters with at least 50 CRC balance
+     * const richInviters = await rpc.sdk.getValidInviters(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   '50.0'
+     * );
+     * ```
+     */
+    async getValidInviters(address, minimumBalance) {
+        const normalizedAddress = normalizeAddress(address);
+        const response = await this.client.call('circles_getValidInviters', minimumBalance ? [normalizedAddress, minimumBalance] : [normalizedAddress]);
+        return checksumAddresses(response);
+    }
+    /**
+     * Get transaction history with enriched participant profiles and metadata
+     *
+     * Replaces circles_events + multiple getProfileByAddress calls + client-side event processing.
+     * Returns transaction history ready for UI display with participant names and avatars.
+     *
+     * @param address - Avatar address to query
+     * @param fromBlock - Starting block number
+     * @param toBlock - Optional ending block number (null for latest)
+     * @param limit - Maximum number of transactions (default: 50)
+     * @returns Enriched transaction history with participant profiles
+     *
+     * @example
+     * ```typescript
+     * const history = await rpc.sdk.getTransactionHistoryEnriched(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   30282299,
+     *   null,
+     *   20
+     * );
+     *
+     * for (const tx of history.results) {
+     *   console.log(`Tx: ${tx.transactionHash}, event: ${JSON.stringify(tx.event)}`);
+     *   // Access participant profiles via tx.participants[address]
+     * }
+     * ```
+     */
+    async getTransactionHistoryEnriched(address, fromBlock = 0, toBlock = null, limit = 50, cursor) {
+        const normalizedAddress = normalizeAddress(address);
+        const response = await this.client.call('circles_getTransactionHistoryEnriched', [normalizedAddress, fromBlock, toBlock, limit, cursor ?? null]);
+        return {
+            hasMore: response.hasMore,
+            nextCursor: response.nextCursor,
+            results: checksumAddresses(response.results),
+        };
+    }
+    /**
+     * Unified search across profiles by address prefix OR name/description text
+     *
+     * Combines address lookup and full-text search in a single endpoint.
+     * Automatically detects search type based on query format (0x prefix = address search).
+     *
+     * @param query - Search query (address prefix or name/description text)
+     * @param limit - Maximum number of results (default: 20)
+     * @param cursor - Pagination cursor from previous response (null for first page)
+     * @param types - Optional array of avatar types to filter by
+     * @returns Unified search results with profiles
+     *
+     * @example
+     * ```typescript
+     * // Search by name
+     * const byName = await rpc.sdk.searchProfileByAddressOrName('Alice');
+     *
+     * // Paginate through results
+     * const page1 = await rpc.sdk.searchProfileByAddressOrName('developer', 10);
+     * const page2 = await rpc.sdk.searchProfileByAddressOrName('developer', 10, page1.nextCursor);
+     * ```
+     */
+    async searchProfileByAddressOrName(query, limit = 20, cursor, types) {
+        return this.client.call('circles_searchProfileByAddressOrName', types ? [query, limit, cursor ?? null, types] : [query, limit, cursor ?? null]);
+    }
+}

package/dist/methods/token.d.ts

@@ -1,6 +1,5 @@
 import type { RpcClient } from '../client.js';
-import type { Address, TokenInfo, TokenHolder, SortOrder } from '@aboutcircles/sdk-types';
-import { PagedQuery } from '../pagedQuery.js';
+import type { Address, TokenInfo, TokenHolderRow, PagedResponse } from '@aboutcircles/sdk-types';
 /**
  * Token information RPC methods
  */
@@ -39,23 +38,18 @@ export declare class TokenMethods {
      * Get token holders for a specific token address with pagination
      *
      * @param tokenAddress - The token address to query holders for
-     * @param limit - Maximum number of results per page (default: 100)
-     * @param sortOrder - Sort order for results (default: 'DESC' - highest balance first)
-     * @returns PagedQuery instance for token holders
+     * @param limit - Maximum number of results to return (default: 100, max: 1000)
+     * @returns Array of token holders with their balances
      *
      * @example
      * ```typescript
-     * const holdersQuery = rpc.token.getTokenHolders('0x42cedde51198d1773590311e2a340dc06b24cb37', 10);
-     *
-     * while (await holdersQuery.queryNextPage()) {
-     *   const page = holdersQuery.currentPage!;
-     *   console.log(`Found ${page.size} holders`);
-     *   page.results.forEach(holder => {
-     *     console.log(`${holder.account}: ${holder.demurragedTotalBalance}`);
-     *   });
-     * }
+     * const holders = await rpc.token.getTokenHolders('0x42cedde51198d1773590311e2a340dc06b24cb37', 100);
+     * console.log(`Found ${holders.length} holders`);
+     * holders.forEach(holder => {
+     *   console.log(`${holder.account}: ${holder.balance}`);
+     * });
      * ```
      */
-    getTokenHolders(tokenAddress: Address, limit?: number, sortOrder?: SortOrder): PagedQuery<TokenHolder>;
+    getTokenHolders(tokenAddress: Address, limit?: number, cursor?: string | null): Promise<PagedResponse<TokenHolderRow>>;
 }
 //# sourceMappingURL=token.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../src/methods/token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAE1F,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;GAEG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC;;;;;;;;;;;OAWG;IACG,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAKpE;;;;;;;;;;;;;OAaG;IACG,iBAAiB,CAAC,SAAS,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAenE;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAAe,CACb,YAAY,EAAE,OAAO,EACrB,KAAK,GAAE,MAAY,EACnB,SAAS,GAAE,SAAkB,GAC5B,UAAU,CAAC,WAAW,CAAC;CAiC3B"}
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../src/methods/token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAIjG;;GAEG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC;;;;;;;;;;;OAWG;IACG,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAKpE;;;;;;;;;;;;;OAaG;IACG,iBAAiB,CAAC,SAAS,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAenE;;;;;;;;;;;;;;;OAeG;IACG,eAAe,CACnB,YAAY,EAAE,OAAO,EACrB,KAAK,GAAE,MAAY,EACnB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;CAY1C"}

package/dist/methods/token.js

@@ -51,49 +51,24 @@ export class TokenMethods {
      * Get token holders for a specific token address with pagination
      *
      * @param tokenAddress - The token address to query holders for
-     * @param limit - Maximum number of results per page (default: 100)
-     * @param sortOrder - Sort order for results (default: 'DESC' - highest balance first)
-     * @returns PagedQuery instance for token holders
+     * @param limit - Maximum number of results to return (default: 100, max: 1000)
+     * @returns Array of token holders with their balances
      *
      * @example
      * ```typescript
-     * const holdersQuery = rpc.token.getTokenHolders('0x42cedde51198d1773590311e2a340dc06b24cb37', 10);
-     *
-     * while (await holdersQuery.queryNextPage()) {
-     *   const page = holdersQuery.currentPage!;
-     *   console.log(`Found ${page.size} holders`);
-     *   page.results.forEach(holder => {
-     *     console.log(`${holder.account}: ${holder.demurragedTotalBalance}`);
-     *   });
-     * }
+     * const holders = await rpc.token.getTokenHolders('0x42cedde51198d1773590311e2a340dc06b24cb37', 100);
+     * console.log(`Found ${holders.length} holders`);
+     * holders.forEach(holder => {
+     *   console.log(`${holder.account}: ${holder.balance}`);
+     * });
      * ```
      */
-    getTokenHolders(tokenAddress, limit = 100, sortOrder = 'DESC') {
-        const normalizedTokenAddress = normalizeAddress(tokenAddress);
-        return new PagedQuery(this.client, {
-            namespace: 'V_CrcV2',
-            table: 'BalancesByAccountAndToken',
-            columns: ['account', 'tokenAddress', 'demurragedTotalBalance'],
-            filter: [{
-                    Type: 'FilterPredicate',
-                    FilterType: 'Equals',
-                    Column: 'tokenAddress',
-                    Value: normalizedTokenAddress
-                }],
-            cursorColumns: [
-                { name: 'demurragedTotalBalance', sortOrder },
-                { name: 'account', sortOrder: 'ASC' } // Secondary sort for deterministic ordering
-            ],
-            orderColumns: [
-                { Column: 'demurragedTotalBalance', SortOrder: sortOrder },
-                { Column: 'account', SortOrder: 'ASC' }
-            ],
-            limit,
-            sortOrder
-        }, (row) => ({
-            account: row.account,
-            tokenAddress: row.tokenAddress,
-            demurragedTotalBalance: row.demurragedTotalBalance
-        }));
+    async getTokenHolders(tokenAddress, limit = 100, cursor) {
+        const response = await this.client.call('circles_getTokenHolders', [normalizeAddress(tokenAddress), limit, cursor ?? null]);
+        return {
+            hasMore: response.hasMore,
+            nextCursor: response.nextCursor,
+            results: checksumAddresses(response.results),
+        };
     }
 }

package/dist/methods/transaction.d.ts

@@ -1,7 +1,5 @@
 import type { RpcClient } from '../client.js';
-import type { Address } from '@aboutcircles/sdk-types';
-import type { TransactionHistoryRow } from '../types.js';
-import { PagedQuery } from '../pagedQuery.js';
+import type { Address, TransactionHistoryRow, EnrichedTransaction, PagedResponse } from '@aboutcircles/sdk-types';
 /**
  * Transaction history RPC methods
  */
@@ -9,33 +7,34 @@ export declare class TransactionMethods {
     private client;
     constructor(client: RpcClient);
     /**
-     * Get transaction history for an address using cursor-based pagination
+     * Get transaction history for an address
      *
-     * Returns a PagedQuery instance that can be used to fetch transaction history page by page.
-     * Automatically calculates circle amounts for each v2 transaction.
+     * Uses the native RPC method which efficiently queries transfers and calculates
+     * all circle amount formats server-side. Fetches all results using cursor-based
+     * pagination up to the specified limit.
      *
      * @param avatar - Avatar address to query transaction history for
-     * @param limit - Number of transactions per page (default: 50)
-     * @param sortOrder - Sort order for results (default: 'DESC')
-     * @returns PagedQuery instance for iterating through transaction history
+     * @param limit - Maximum number of transactions to return (default: 50)
+     * @returns Array of transaction history rows with all circle amount formats
      *
      * @example
      * ```typescript
-     * const query = rpc.transaction.getTransactionHistory('0xAvatar...', 50);
-     *
-     * // Get first page
-     * await query.queryNextPage();
-     * query.currentPage.results.forEach(tx => {
+     * const history = await rpc.transaction.getTransactionHistory('0xAvatar...', 50);
+     * history.forEach(tx => {
      *   console.log(`${tx.from} -> ${tx.to}: ${tx.circles} CRC`);
      * });
-     *
-     * // Get next page if available
-     * if (query.currentPage.hasMore) {
-     *   await query.queryNextPage();
-     *   // Process next page...
-     * }
      * ```
      */
-    getTransactionHistory(avatar: Address, limit?: number, sortOrder?: 'ASC' | 'DESC'): PagedQuery<TransactionHistoryRow>;
+    getTransactionHistory(avatar: Address, limit?: number, cursor?: string | null): Promise<PagedResponse<TransactionHistoryRow>>;
+    /**
+     * Get enriched transaction history
+     * Includes profile data and pre-calculated balance formats
+     *
+     * @param avatar - Avatar address to query
+     * @param limit - Number of transactions per page (default: 20)
+     * @param cursor - Pagination cursor
+     * @returns Paged response with enriched transactions
+     */
+    getTransactionHistoryEnriched(avatar: Address, fromBlock?: number, toBlock?: number | null, limit?: number, cursor?: string | null): Promise<PagedResponse<EnrichedTransaction>>;
 }
 //# sourceMappingURL=transaction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../src/methods/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAU,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGzD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAiC9C;;GAEG;AACH,qBAAa,kBAAkB;IACjB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,qBAAqB,CACnB,MAAM,EAAE,OAAO,EACf,KAAK,GAAE,MAAW,EAClB,SAAS,GAAE,KAAK,GAAG,MAAe,GACjC,UAAU,CAAC,qBAAqB,CAAC;CAyDrC"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../src/methods/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGlH;;GAEG;AACH,qBAAa,kBAAkB;IACjB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC;;;;;;;;;;;;;;;;;;OAkBG;IACG,qBAAqB,CACzB,MAAM,EAAE,OAAO,EACf,KAAK,GAAE,MAAW,EAClB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;IAahD;;;;;;;;OAQG;IACG,6BAA6B,CACjC,MAAM,EAAE,OAAO,EACf,SAAS,GAAE,MAAU,EACrB,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,KAAK,GAAE,MAAW,EAClB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;CAY/C"}

package/dist/methods/transaction.js

@@ -1,26 +1,4 @@
 import { normalizeAddress, checksumAddresses } from '../utils.js';
-import { CirclesConverter } from '@aboutcircles/sdk-utils/circlesConverter';
-import { PagedQuery } from '../pagedQuery.js';
-/**
- * Calculate circle amounts for v2 transactions
- */
-function calculateCircleAmounts(value, timestamp) {
-    // v2: value is attoCircles (demurraged)
-    const attoCircles = BigInt(value);
-    const circles = CirclesConverter.attoCirclesToCircles(attoCircles);
-    const attoCrc = CirclesConverter.attoCirclesToAttoCrc(attoCircles, BigInt(timestamp));
-    const crc = CirclesConverter.attoCirclesToCircles(attoCrc);
-    const staticAttoCircles = CirclesConverter.attoCirclesToAttoStaticCircles(attoCircles, BigInt(timestamp));
-    const staticCircles = CirclesConverter.attoCirclesToCircles(staticAttoCircles);
-    return {
-        attoCircles,
-        circles,
-        staticAttoCircles,
-        staticCircles,
-        attoCrc,
-        crc,
-    };
-}
 /**
  * Transaction history RPC methods
  */
@@ -30,82 +8,47 @@ export class TransactionMethods {
         this.client = client;
     }
     /**
-     * Get transaction history for an address using cursor-based pagination
+     * Get transaction history for an address
      *
-     * Returns a PagedQuery instance that can be used to fetch transaction history page by page.
-     * Automatically calculates circle amounts for each v2 transaction.
+     * Uses the native RPC method which efficiently queries transfers and calculates
+     * all circle amount formats server-side. Fetches all results using cursor-based
+     * pagination up to the specified limit.
      *
      * @param avatar - Avatar address to query transaction history for
-     * @param limit - Number of transactions per page (default: 50)
-     * @param sortOrder - Sort order for results (default: 'DESC')
-     * @returns PagedQuery instance for iterating through transaction history
+     * @param limit - Maximum number of transactions to return (default: 50)
+     * @returns Array of transaction history rows with all circle amount formats
      *
      * @example
      * ```typescript
-     * const query = rpc.transaction.getTransactionHistory('0xAvatar...', 50);
-     *
-     * // Get first page
-     * await query.queryNextPage();
-     * query.currentPage.results.forEach(tx => {
+     * const history = await rpc.transaction.getTransactionHistory('0xAvatar...', 50);
+     * history.forEach(tx => {
      *   console.log(`${tx.from} -> ${tx.to}: ${tx.circles} CRC`);
      * });
-     *
-     * // Get next page if available
-     * if (query.currentPage.hasMore) {
-     *   await query.queryNextPage();
-     *   // Process next page...
-     * }
      * ```
      */
-    getTransactionHistory(avatar, limit = 50, sortOrder = 'DESC') {
-        const normalized = normalizeAddress(avatar);
-        const filter = [
-            {
-                Type: 'Conjunction',
-                ConjunctionType: 'And',
-                Predicates: [
-                    {
-                        Type: 'FilterPredicate',
-                        FilterType: 'Equals',
-                        Column: 'version',
-                        Value: 2,
-                    },
-                    {
-                        Type: 'Conjunction',
-                        ConjunctionType: 'Or',
-                        Predicates: [
-                            {
-                                Type: 'FilterPredicate',
-                                FilterType: 'Equals',
-                                Column: 'from',
-                                Value: normalized,
-                            },
-                            {
-                                Type: 'FilterPredicate',
-                                FilterType: 'Equals',
-                                Column: 'to',
-                                Value: normalized,
-                            },
-                        ],
-                    },
-                ],
-            },
-        ];
-        return new PagedQuery(this.client, {
-            namespace: 'V_Crc',
-            table: 'TransferSummary',
-            sortOrder,
-            columns: [], // Empty array returns all columns
-            filter,
-            limit,
-        }, (row) => {
-            // Calculate circle amounts
-            const amounts = calculateCircleAmounts(row.value, row.timestamp);
-            const result = {
-                ...row,
-                ...amounts,
-            };
-            return checksumAddresses(result);
-        });
+    async getTransactionHistory(avatar, limit = 50, cursor) {
+        const response = await this.client.call('circles_getTransactionHistory', [normalizeAddress(avatar), limit, cursor ?? null]);
+        return {
+            hasMore: response.hasMore,
+            nextCursor: response.nextCursor,
+            results: checksumAddresses(response.results),
+        };
+    }
+    /**
+     * Get enriched transaction history
+     * Includes profile data and pre-calculated balance formats
+     *
+     * @param avatar - Avatar address to query
+     * @param limit - Number of transactions per page (default: 20)
+     * @param cursor - Pagination cursor
+     * @returns Paged response with enriched transactions
+     */
+    async getTransactionHistoryEnriched(avatar, fromBlock = 0, toBlock = null, limit = 20, cursor) {
+        const response = await this.client.call('circles_getTransactionHistoryEnriched', [normalizeAddress(avatar), fromBlock, toBlock, limit, cursor ?? null]);
+        return {
+            hasMore: response.hasMore,
+            nextCursor: response.nextCursor,
+            results: checksumAddresses(response.results),
+        };
     }
 }