@aboutcircles/sdk-rpc 0.1.0

package/dist/methods/invitation.js

@@ -0,0 +1,230 @@
+import { normalizeAddress, checksumAddresses } from '../utils';
+/**
+ * Invitation RPC methods
+ */
+export class InvitationMethods {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    transformQueryResponse(response) {
+        const { columns, rows } = response;
+        return rows.map((row) => {
+            const obj = {};
+            columns.forEach((col, index) => {
+                obj[col] = row[index];
+            });
+            return obj;
+        });
+    }
+    /**
+     * Get the avatar that invited a specific avatar
+     *
+     * @param address - The address of the invited avatar
+     * @returns The address of the inviting avatar or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const inviter = await rpc.invitation.getInvitedBy('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     * console.log(inviter); // '0x...'
+     * ```
+     */
+    async getInvitedBy(address) {
+        const normalized = normalizeAddress(address);
+        const results = await this.client.call('circles_query', [
+            {
+                Namespace: 'CrcV2',
+                Table: 'RegisterHuman',
+                Columns: ['inviter'],
+                Filter: [
+                    {
+                        Type: 'FilterPredicate',
+                        FilterType: 'Equals',
+                        Column: 'avatar',
+                        Value: normalized,
+                    },
+                ],
+                Order: [
+                    {
+                        Column: 'blockNumber',
+                        SortOrder: 'DESC',
+                    },
+                ],
+                Limit: 1,
+            },
+        ]);
+        if (results.length > 0) {
+            return checksumAddresses(results[0].inviter);
+        }
+        return undefined;
+    }
+    /**
+     * Get the list of avatars who have invited this avatar
+     * Checks v2 trust relations and validates that inviters have enough balance
+     *
+     * @param address - The address to check for invitations
+     * @returns Array of avatar info for valid inviters
+     *
+     * @example
+     * ```typescript
+     * const invitations = await rpc.invitation.getInvitations('0xde374ece6fa50e781e81aac78e811b33d16912c7');
+     * console.log(invitations); // Array of AvatarInfo
+     * ```
+     */
+    async getInvitations(address) {
+        const normalized = normalizeAddress(address);
+        const MIN_TOKENS_REQUIRED = 96;
+        // Check if the avatar is still on v1
+        const avatarInfoResults = await this.client.call('circles_getAvatarInfoBatch', [[normalized]]);
+        const avatarInfo = avatarInfoResults.length > 0 ? avatarInfoResults[0] : undefined;
+        if (avatarInfo?.version === 2) {
+            // Already on v2, no invitations needed
+            return [];
+        }
+        // Get trust relations where others trust this avatar
+        const response = await this.client.call('circles_query', [
+            {
+                Namespace: 'V_Crc',
+                Table: 'TrustRelations',
+                Columns: ['truster', 'trustee'],
+                Filter: [
+                    {
+                        Type: 'Conjunction',
+                        ConjunctionType: 'And',
+                        Predicates: [
+                            {
+                                Type: 'FilterPredicate',
+                                FilterType: 'Equals',
+                                Column: 'version',
+                                Value: 2,
+                            },
+                            {
+                                Type: 'FilterPredicate',
+                                FilterType: 'Equals',
+                                Column: 'trustee',
+                                Value: normalized,
+                            },
+                        ],
+                    },
+                ],
+                Order: [],
+            },
+        ]);
+        const trustRelations = this.transformQueryResponse(response);
+        const v2Trusters = trustRelations.map((r) => r.truster);
+        if (v2Trusters.length === 0) {
+            return [];
+        }
+        // Get avatar info for all trusters
+        const trusterInfos = await this.client.call('circles_getAvatarInfoBatch', [v2Trusters]);
+        const humanInviters = [];
+        for (const trusterInfo of trusterInfos) {
+            // Only humans can invite other humans
+            if (!trusterInfo?.isHuman) {
+                continue;
+            }
+            // Check if the inviter has enough tokens
+            const balances = await this.client.call('circles_getTokenBalances', [trusterInfo.avatar]);
+            const inviterOwnToken = balances.find((b) => normalizeAddress(b.tokenAddress) === normalizeAddress(trusterInfo.avatar));
+            if (inviterOwnToken && inviterOwnToken.circles >= MIN_TOKENS_REQUIRED) {
+                humanInviters.push(trusterInfo);
+            }
+        }
+        return checksumAddresses(humanInviters);
+    }
+    /**
+     * Get the list of accounts that were invited by a specific avatar
+     *
+     * @param address - The address of the inviter
+     * @param accepted - If true, returns accepted invitations; if false, returns pending invitations
+     * @returns Array of invited addresses
+     *
+     * @example
+     * ```typescript
+     * // Get accepted invitations
+     * const accepted = await rpc.invitation.getInvitationsFrom(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   true
+     * );
+     *
+     * // Get pending invitations
+     * const pending = await rpc.invitation.getInvitationsFrom(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   false
+     * );
+     * ```
+     */
+    async getInvitationsFrom(address, accepted = false) {
+        const normalized = normalizeAddress(address);
+        if (accepted) {
+            // Query for accounts that have registered using this avatar as inviter
+            const response = await this.client.call('circles_query', [
+                {
+                    Namespace: 'CrcV2',
+                    Table: 'RegisterHuman',
+                    Columns: ['avatar'],
+                    Filter: [
+                        {
+                            Type: 'FilterPredicate',
+                            FilterType: 'Equals',
+                            Column: 'inviter',
+                            Value: normalized,
+                        },
+                    ],
+                    Order: [
+                        {
+                            Column: 'blockNumber',
+                            SortOrder: 'DESC',
+                        },
+                    ],
+                },
+            ]);
+            const results = this.transformQueryResponse(response);
+            const avatars = results.map((r) => r.avatar);
+            return checksumAddresses(avatars);
+        }
+        else {
+            // Find accounts that this avatar trusts without mutual trust
+            const response = await this.client.call('circles_query', [
+                {
+                    Namespace: 'V_Crc',
+                    Table: 'TrustRelations',
+                    Columns: ['trustee', 'truster'],
+                    Filter: [
+                        {
+                            Type: 'Conjunction',
+                            ConjunctionType: 'And',
+                            Predicates: [
+                                {
+                                    Type: 'FilterPredicate',
+                                    FilterType: 'Equals',
+                                    Column: 'version',
+                                    Value: 2,
+                                },
+                                {
+                                    Type: 'FilterPredicate',
+                                    FilterType: 'Equals',
+                                    Column: 'truster',
+                                    Value: normalized,
+                                },
+                            ],
+                        },
+                    ],
+                    Order: [],
+                },
+            ]);
+            const trustRelations = this.transformQueryResponse(response);
+            const v2Trusted = trustRelations.map((r) => r.trustee);
+            if (v2Trusted.length === 0) {
+                return [];
+            }
+            // Get avatar info for trusted accounts
+            const trustedAvatarsInfo = await this.client.call('circles_getAvatarInfoBatch', [v2Trusted]);
+            // Create a Set of registered avatars (filter out null values) - normalize for comparison
+            const registeredAvatarsSet = new Set(trustedAvatarsInfo.filter((a) => a !== null).map((a) => normalizeAddress(a.avatar)));
+            // Return only unregistered accounts (pending invitations)
+            const pending = v2Trusted.filter((addr) => !registeredAvatarsSet.has(normalizeAddress(addr)));
+            return checksumAddresses(pending);
+        }
+    }
+}

package/dist/methods/pathfinder.d.ts

@@ -0,0 +1,41 @@
+import type { RpcClient } from '../client';
+import type { FindPathParams, PathfindingResult } from '@aboutcircles/sdk-types';
+/**
+ * Circles V1 and V2 balance and pathfinding methods
+ */
+export declare class PathfinderMethods {
+    private client;
+    constructor(client: RpcClient);
+    /**
+     * Calculate a path between two addresses with a target flow
+     *
+     * @param params - Path finding parameters
+     * @returns The computed path with transfers (amounts as bigint)
+     *
+     * @example
+     * ```typescript
+     * const path = await rpc.pathfinder.findPath({
+     *   from: '0x749c930256b47049cb65adcd7c25e72d5de44b3b',
+     *   to: '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   targetFlow: 99999999999999999999999999999999999n
+     * });
+     * ```
+     */
+    findPath(params: FindPathParams): Promise<PathfindingResult>;
+    /**
+     * Find the maximum flow between two addresses
+     *
+     * @param params - Path finding parameters (without targetFlow)
+     * @returns The maximum flow as bigint
+     *
+     * @example
+     * ```typescript
+     * const maxFlow = await rpc.pathfinder.findMaxFlow({
+     *   from: '0x749c930256b47049cb65adcd7c25e72d5de44b3b',
+     *   to: '0xde374ece6fa50e781e81aac78e811b33d16912c7'
+     * });
+     * ```
+     */
+    findMaxFlow(params: Omit<FindPathParams, 'targetFlow'>): Promise<bigint>;
+}
+//# sourceMappingURL=pathfinder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathfinder.d.ts","sourceRoot":"","sources":["../../src/methods/pathfinder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGjF;;GAEG;AACH,qBAAa,iBAAiB;IAChB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAYlE;;;;;;;;;;;;;OAaG;IACG,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAQ/E"}

package/dist/methods/pathfinder.js

@@ -0,0 +1,53 @@
+import { normalizeFindPathParams, parseStringsToBigInt, checksumAddresses } from '../utils';
+/**
+ * Circles V1 and V2 balance and pathfinding methods
+ */
+export class PathfinderMethods {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Calculate a path between two addresses with a target flow
+     *
+     * @param params - Path finding parameters
+     * @returns The computed path with transfers (amounts as bigint)
+     *
+     * @example
+     * ```typescript
+     * const path = await rpc.pathfinder.findPath({
+     *   from: '0x749c930256b47049cb65adcd7c25e72d5de44b3b',
+     *   to: '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   targetFlow: 99999999999999999999999999999999999n
+     * });
+     * ```
+     */
+    async findPath(params) {
+        const normalizedParams = normalizeFindPathParams(params);
+        const result = await this.client.call('circlesV2_findPath', [normalizedParams]);
+        const parsed = parseStringsToBigInt(result);
+        return checksumAddresses(parsed);
+    }
+    /**
+     * Find the maximum flow between two addresses
+     *
+     * @param params - Path finding parameters (without targetFlow)
+     * @returns The maximum flow as bigint
+     *
+     * @example
+     * ```typescript
+     * const maxFlow = await rpc.pathfinder.findMaxFlow({
+     *   from: '0x749c930256b47049cb65adcd7c25e72d5de44b3b',
+     *   to: '0xde374ece6fa50e781e81aac78e811b33d16912c7'
+     * });
+     * ```
+     */
+    async findMaxFlow(params) {
+        const targetFlow = 9999999999999999999999999999999999999n;
+        const path = await this.findPath({
+            ...params,
+            targetFlow
+        });
+        return BigInt(path.maxFlow);
+    }
+}

package/dist/methods/profile.d.ts

@@ -0,0 +1,109 @@
+import type { RpcClient } from '../client';
+import type { Address, Profile } from '@aboutcircles/sdk-types';
+import type { SearchResultProfile } from '../types';
+/**
+ * Profile RPC methods
+ */
+export declare class ProfileMethods {
+    private client;
+    constructor(client: RpcClient);
+    /**
+     * Get a profile by its CID
+     *
+     * @param cid - The CID of the profile
+     * @returns Profile information or null if not found
+     *
+     * @example
+     * ```typescript
+     * const profile = await rpc.profile.getProfileByCid('Qmb2s3hjxXXcFqWvDDSPCd1fXXa9gcFJd8bzdZNNAvkq9W');
+     * console.log(profile);
+     * ```
+     */
+    getProfileByCid(cid: string): Promise<Profile | null>;
+    /**
+     * Get many profiles by CID in batch
+     *
+     * @param cids - Array of CIDs (null values are allowed in the array)
+     * @returns Array of profiles (null for not found)
+     *
+     * @example
+     * ```typescript
+     * const profiles = await rpc.profile.getProfileByCidBatch([
+     *   'Qmb2s3hjxXXcFqWvDDSPCd1fXXa9gcFJd8bzdZNNAvkq9W',
+     *   null,
+     *   'QmZuR1Jkhs9RLXVY28eTTRSnqbxLTBSoggp18Yde858xCM'
+     * ]);
+     * ```
+     */
+    getProfileByCidBatch(cids: (string | null)[]): Promise<(Profile | null)[]>;
+    /**
+     * Query the profile for an avatar address
+     *
+     * @param address - The avatar address
+     * @returns Profile information or null if not found
+     *
+     * @example
+     * ```typescript
+     * const profile = await rpc.profile.getProfileByAddress('0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7');
+     * console.log(profile);
+     * ```
+     */
+    getProfileByAddress(address: Address): Promise<Profile | null>;
+    /**
+     * Query profiles by address in batch
+     *
+     * @param addresses - Array of addresses (null values are allowed in the array)
+     * @returns Array of profiles (null for not found)
+     *
+     * @example
+     * ```typescript
+     * const profiles = await rpc.profile.getProfileByAddressBatch([
+     *   '0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7',
+     *   null,
+     *   '0xf712d3b31de494b5c0ea51a6a407460ca66b12e8'
+     * ]);
+     * ```
+     */
+    getProfileByAddressBatch(addresses: (Address | null)[]): Promise<(Profile | null)[]>;
+    /**
+     * Search profiles by name, description or address
+     *
+     * @param query - Search query string
+     * @param limit - Maximum number of results (default: 10)
+     * @param offset - Offset for pagination (default: 0)
+     * @param avatarTypes - Optional array of avatar types to filter by (e.g., ['CrcV2_RegisterHuman', 'CrcV2_RegisterGroup'])
+     * @returns Array of matching profiles
+     *
+     * @example
+     * ```typescript
+     * const results = await rpc.profile.searchProfiles('alice', 10, 0);
+     * console.log(results);
+     *
+     * // Search only humans
+     * const humans = await rpc.profile.searchProfiles('alice', 10, 0, ['CrcV2_RegisterHuman']);
+     * ```
+     */
+    searchProfiles(query: string, limit?: number, offset?: number, avatarTypes?: string[]): Promise<SearchResultProfile[]>;
+    /**
+     * Search profiles by address or username
+     * If the query is a valid address, it will search by address first,
+     * otherwise it will search by name/description
+     *
+     * @param query - Search query (address or username)
+     * @param limit - Maximum number of results (default: 10)
+     * @param offset - Offset for pagination (default: 0)
+     * @param avatarTypes - Optional array of avatar types to filter by
+     * @returns Array of matching profiles, with exact address match (if valid) at the top
+     *
+     * @example
+     * ```typescript
+     * // Search by username
+     * const results = await rpc.profile.searchByAddressOrName('alice', 20);
+     *
+     * // Search by address
+     * const results = await rpc.profile.searchByAddressOrName('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb', 20);
+     * ```
+     */
+    searchByAddressOrName(query: string, limit?: number, offset?: number, avatarTypes?: string[]): Promise<SearchResultProfile[]>;
+}
+//# sourceMappingURL=profile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/methods/profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD;;GAEG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC;;;;;;;;;;;OAWG;IACG,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAI3D;;;;;;;;;;;;;;OAcG;IACG,oBAAoB,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;IAOhF;;;;;;;;;;;OAWG;IACG,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAMpE;;;;;;;;;;;;;;OAcG;IACG,wBAAwB,CAAC,SAAS,EAAE,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;IAO1F;;;;;;;;;;;;;;;;;OAiBG;IACG,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAW,EAClB,MAAM,GAAE,MAAU,EAClB,WAAW,CAAC,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAYjC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,qBAAqB,CACzB,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAW,EAClB,MAAM,GAAE,MAAU,EAClB,WAAW,CAAC,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC,mBAAmB,EAAE,CAAC;CA8ClC"}

package/dist/methods/profile.js

@@ -0,0 +1,166 @@
+import { normalizeAddress } from '../utils';
+/**
+ * Profile RPC methods
+ */
+export class ProfileMethods {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a profile by its CID
+     *
+     * @param cid - The CID of the profile
+     * @returns Profile information or null if not found
+     *
+     * @example
+     * ```typescript
+     * const profile = await rpc.profile.getProfileByCid('Qmb2s3hjxXXcFqWvDDSPCd1fXXa9gcFJd8bzdZNNAvkq9W');
+     * console.log(profile);
+     * ```
+     */
+    async getProfileByCid(cid) {
+        return this.client.call('circles_getProfileByCid', [cid]);
+    }
+    /**
+     * Get many profiles by CID in batch
+     *
+     * @param cids - Array of CIDs (null values are allowed in the array)
+     * @returns Array of profiles (null for not found)
+     *
+     * @example
+     * ```typescript
+     * const profiles = await rpc.profile.getProfileByCidBatch([
+     *   'Qmb2s3hjxXXcFqWvDDSPCd1fXXa9gcFJd8bzdZNNAvkq9W',
+     *   null,
+     *   'QmZuR1Jkhs9RLXVY28eTTRSnqbxLTBSoggp18Yde858xCM'
+     * ]);
+     * ```
+     */
+    async getProfileByCidBatch(cids) {
+        return this.client.call('circles_getProfileByCidBatch', [cids]);
+    }
+    /**
+     * Query the profile for an avatar address
+     *
+     * @param address - The avatar address
+     * @returns Profile information or null if not found
+     *
+     * @example
+     * ```typescript
+     * const profile = await rpc.profile.getProfileByAddress('0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7');
+     * console.log(profile);
+     * ```
+     */
+    async getProfileByAddress(address) {
+        return this.client.call('circles_getProfileByAddress', [
+            normalizeAddress(address),
+        ]);
+    }
+    /**
+     * Query profiles by address in batch
+     *
+     * @param addresses - Array of addresses (null values are allowed in the array)
+     * @returns Array of profiles (null for not found)
+     *
+     * @example
+     * ```typescript
+     * const profiles = await rpc.profile.getProfileByAddressBatch([
+     *   '0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7',
+     *   null,
+     *   '0xf712d3b31de494b5c0ea51a6a407460ca66b12e8'
+     * ]);
+     * ```
+     */
+    async getProfileByAddressBatch(addresses) {
+        return this.client.call('circles_getProfileByAddressBatch', [addresses.map((addr) => (addr === null ? null : normalizeAddress(addr)))]);
+    }
+    /**
+     * Search profiles by name, description or address
+     *
+     * @param query - Search query string
+     * @param limit - Maximum number of results (default: 10)
+     * @param offset - Offset for pagination (default: 0)
+     * @param avatarTypes - Optional array of avatar types to filter by (e.g., ['CrcV2_RegisterHuman', 'CrcV2_RegisterGroup'])
+     * @returns Array of matching profiles
+     *
+     * @example
+     * ```typescript
+     * const results = await rpc.profile.searchProfiles('alice', 10, 0);
+     * console.log(results);
+     *
+     * // Search only humans
+     * const humans = await rpc.profile.searchProfiles('alice', 10, 0, ['CrcV2_RegisterHuman']);
+     * ```
+     */
+    async searchProfiles(query, limit = 10, offset = 0, avatarTypes) {
+        return this.client.call('circles_searchProfiles', [
+            query.toLowerCase(),
+            limit,
+            offset,
+            avatarTypes
+        ]);
+    }
+    /**
+     * Search profiles by address or username
+     * If the query is a valid address, it will search by address first,
+     * otherwise it will search by name/description
+     *
+     * @param query - Search query (address or username)
+     * @param limit - Maximum number of results (default: 10)
+     * @param offset - Offset for pagination (default: 0)
+     * @param avatarTypes - Optional array of avatar types to filter by
+     * @returns Array of matching profiles, with exact address match (if valid) at the top
+     *
+     * @example
+     * ```typescript
+     * // Search by username
+     * const results = await rpc.profile.searchByAddressOrName('alice', 20);
+     *
+     * // Search by address
+     * const results = await rpc.profile.searchByAddressOrName('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb', 20);
+     * ```
+     */
+    async searchByAddressOrName(query, limit = 10, offset = 0, avatarTypes) {
+        const results = [];
+        // Check if query is a valid address
+        const isAddress = /^0x[a-fA-F0-9]{40}$/.test(query);
+        if (isAddress) {
+            // Try to get profile by address first
+            try {
+                const profile = await this.getProfileByAddress(query);
+                if (profile) {
+                    // Convert Profile to SearchResultProfile by adding address
+                    const searchResult = {
+                        ...profile,
+                        address: query
+                    };
+                    // Check if profile matches avatar type filter
+                    if (!avatarTypes || !searchResult.avatarType || avatarTypes.includes(searchResult.avatarType)) {
+                        results.push(searchResult);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('Failed to get profile by address:', error);
+            }
+        }
+        // Always search by text as well
+        try {
+            const textResults = await this.searchProfiles(query, limit, offset, avatarTypes);
+            // If we already added an address match, filter it out from text results to avoid duplicates
+            if (isAddress && results.length > 0) {
+                const addressLower = query.toLowerCase();
+                const filteredResults = textResults.filter(p => p.address?.toLowerCase() !== addressLower);
+                results.push(...filteredResults);
+            }
+            else {
+                results.push(...textResults);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to search profiles by text:', error);
+        }
+        return results.slice(0, limit);
+    }
+}

package/dist/methods/query.d.ts

@@ -0,0 +1,79 @@
+import type { RpcClient } from '../client';
+import type { QueryParams, TableInfo, EventType } from '@aboutcircles/sdk-types';
+/**
+ * Query and table RPC methods
+ */
+export declare class QueryMethods {
+    private client;
+    constructor(client: RpcClient);
+    /**
+     * Query tables with filters
+     *
+     * @param params - Query parameters including namespace, table, columns, filters, and ordering
+     * @returns Array of query results
+     *
+     * @example
+     * ```typescript
+     * const results = await rpc.query.query({
+     *   Namespace: 'V_CrcV2',
+     *   Table: 'TrustRelations',
+     *   Columns: [],
+     *   Filter: [{
+     *     Type: 'Conjunction',
+     *     ConjunctionType: 'Or',
+     *     Predicates: [
+     *       {
+     *         Type: 'FilterPredicate',
+     *         FilterType: 'Equals',
+     *         Column: 'truster',
+     *         Value: '0xae3a29a9ff24d0e936a5579bae5c4179c4dff565'
+     *       },
+     *       {
+     *         Type: 'FilterPredicate',
+     *         FilterType: 'Equals',
+     *         Column: 'trustee',
+     *         Value: '0xae3a29a9ff24d0e936a5579bae5c4179c4dff565'
+     *       }
+     *     ]
+     *   }],
+     *   Order: []
+     * });
+     * ```
+     */
+    query<T = unknown>(params: QueryParams): Promise<T[]>;
+    /**
+     * Return all available namespaces and tables which can be queried
+     *
+     * @returns Array of table information
+     *
+     * @example
+     * ```typescript
+     * const tables = await rpc.query.tables();
+     * console.log(tables);
+     * ```
+     */
+    tables(): Promise<TableInfo[]>;
+    /**
+     * Query events of specific types within a block range
+     *
+     * @param fromBlock - Starting block number (null for genesis)
+     * @param toBlock - Ending block number (null for latest)
+     * @param eventTypes - Array of event types to filter (null for all)
+     * @param address - Optional address filter
+     * @param includeTransactionData - Whether to include transaction data
+     * @returns Array of events
+     *
+     * @example
+     * ```typescript
+     * const events = await rpc.query.events(
+     *   38000000,
+     *   null,
+     *   ['CrcV1_Trust'],
+     *   null,
+     *   false
+     * );
+     * ```
+     */
+    events<T = unknown>(fromBlock: number | null, toBlock: number | null, eventTypes?: EventType[] | null, address?: string | null, includeTransactionData?: boolean): Promise<T[]>;
+}
+//# sourceMappingURL=query.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/methods/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGjF;;GAEG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAK3D;;;;;;;;;;OAUG;IACG,MAAM,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAIpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,MAAM,CAAC,CAAC,GAAG,OAAO,EACtB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,UAAU,GAAE,SAAS,EAAE,GAAG,IAAW,EACrC,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,sBAAsB,GAAE,OAAe,GACtC,OAAO,CAAC,CAAC,EAAE,CAAC;CAOhB"}