@aboutcircles/sdk-rpc 0.1.0

package/dist/methods/trust.js

@@ -0,0 +1,245 @@
+import { normalizeAddress, checksumAddresses } from '../utils';
+import { PagedQuery } from '../pagedQuery';
+/**
+ * Trust relation RPC methods
+ */
+export class TrustMethods {
+    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;
+        });
+    }
+    /**
+     * Query the common trust relations of two addresses
+     * (only common outgoing trust relations are considered)
+     *
+     * @param address1 - First address
+     * @param address2 - Second address
+     * @returns Array of common trusted addresses
+     *
+     * @example
+     * ```typescript
+     * const commonTrust = await rpc.trust.getCommonTrust(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+     *   '0xe8fc7a2d0573e5164597b05f14fa9a7fca7b215c'
+     * );
+     * ```
+     */
+    // @todo check if we need to normilize addr before the call
+    async getCommonTrust(address1, address2) {
+        const result = await this.client.call('circles_getCommonTrust', [
+            normalizeAddress(address1),
+            normalizeAddress(address2),
+        ]);
+        return checksumAddresses(result);
+    }
+    /**
+     * Get trust relations for an address using cursor-based pagination
+     *
+     * Returns a PagedQuery instance for iterating through all v2 trust relations for the given avatar.
+     *
+     * @param avatar - Avatar address to query trust relations for
+     * @param limit - Number of trust relations per page (default: 100)
+     * @param sortOrder - Sort order for results (default: 'DESC')
+     * @returns PagedQuery instance for iterating through trust relations
+     *
+     * @example
+     * ```typescript
+     * const query = rpc.trust.getTrustRelations('0xAvatar...', 100);
+     *
+     * // Get first page
+     * await query.queryNextPage();
+     * query.currentPage.results.forEach(relation => {
+     *   console.log(`${relation.truster} trusts ${relation.trustee}`);
+     * });
+     * ```
+     */
+    getTrustRelations(avatar, limit = 100, 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: 'trustee',
+                                Value: normalized,
+                            },
+                            {
+                                Type: 'FilterPredicate',
+                                FilterType: 'Equals',
+                                Column: 'truster',
+                                Value: normalized,
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        return new PagedQuery(this.client, {
+            namespace: 'V_Crc',
+            table: 'TrustRelations',
+            sortOrder,
+            columns: [
+                'blockNumber',
+                'timestamp',
+                'transactionIndex',
+                'logIndex',
+                'transactionHash',
+                'version',
+                'trustee',
+                'truster',
+                'expiryTime',
+            ],
+            filter,
+            limit,
+        }, (row) => checksumAddresses(row));
+    }
+    /**
+     * 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.
+     *
+     * @param avatar - Avatar address to query trust relations for
+     * @returns Aggregated trust relations with relationship types
+     *
+     * @example
+     * ```typescript
+     * const aggregated = await rpc.trust.getAggregatedTrustRelations(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7'
+     * );
+     * // Returns: [
+     * //   { subjectAvatar: '0x...', relation: 'mutuallyTrusts', objectAvatar: '0x...', timestamp: 123 },
+     * //   { subjectAvatar: '0x...', relation: 'trusts', objectAvatar: '0x...', timestamp: 456 }
+     * // ]
+     * ```
+     */
+    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,
+            };
+        });
+        return checksumAddresses(result);
+    }
+    /**
+     * Get addresses that trust the given avatar (incoming trust)
+     *
+     * @param avatar - Avatar address to query
+     * @returns Array of trust relations where others trust this avatar
+     *
+     * @example
+     * ```typescript
+     * const trustedBy = await rpc.trust.getTrustedBy(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7'
+     * );
+     * ```
+     */
+    async getTrustedBy(avatar) {
+        const normalized = normalizeAddress(avatar);
+        const relations = await this.getAggregatedTrustRelations(normalized);
+        const filtered = relations.filter((r) => r.relation === 'trustedBy');
+        return checksumAddresses(filtered);
+    }
+    /**
+     * Get addresses that the given avatar trusts (outgoing trust)
+     *
+     * @param avatar - Avatar address to query
+     * @returns Array of trust relations where this avatar trusts others
+     *
+     * @example
+     * ```typescript
+     * const trusts = await rpc.trust.getTrusts(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7'
+     * );
+     * ```
+     */
+    async getTrusts(avatar) {
+        const normalized = normalizeAddress(avatar);
+        const relations = await this.getAggregatedTrustRelations(normalized);
+        const filtered = relations.filter((r) => r.relation === 'trusts');
+        return checksumAddresses(filtered);
+    }
+    /**
+     * Get mutual trust relations for the given avatar
+     *
+     * @param avatar - Avatar address to query
+     * @returns Array of trust relations where both parties trust each other
+     *
+     * @example
+     * ```typescript
+     * const mutualTrusts = await rpc.trust.getMutualTrusts(
+     *   '0xde374ece6fa50e781e81aac78e811b33d16912c7'
+     * );
+     * ```
+     */
+    async getMutualTrusts(avatar) {
+        const normalized = normalizeAddress(avatar);
+        const relations = await this.getAggregatedTrustRelations(normalized);
+        const filtered = relations.filter((r) => r.relation === 'mutuallyTrusts');
+        return checksumAddresses(filtered);
+    }
+}

package/dist/pagedQuery.d.ts

@@ -0,0 +1,106 @@
+import type { RpcClient } from './client';
+import type { PagedQueryParams, OrderBy } from '@aboutcircles/sdk-types';
+import type { CursorColumn, FlexiblePagedResult } from './types';
+/**
+ * A class for querying Circles RPC nodes with cursor-based pagination.
+ * Supports both event-based pagination (default) and custom cursor pagination (for view tables).
+ *
+ * @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',
+ *   sortOrder: 'DESC',
+ *   columns: ['blockNumber', 'transactionIndex', 'logIndex', 'group', 'member'],
+ *   filter: [{ Type: 'FilterPredicate', FilterType: 'Equals', Column: 'group', Value: '0x...' }],
+ *   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
+ * });
+ * ```
+ */
+export declare class PagedQuery<TRow = any> {
+    private readonly params;
+    private readonly client;
+    private readonly rowTransformer?;
+    private readonly cursorColumns;
+    private readonly orderColumns?;
+    get currentPage(): FlexiblePagedResult<TRow> | undefined;
+    private _currentPage?;
+    constructor(client: RpcClient, params: PagedQueryParams & {
+        cursorColumns?: CursorColumn[];
+        orderColumns?: OrderBy[];
+        rowTransformer?: (row: any) => TRow;
+    }, rowTransformer?: (row: any) => TRow);
+    /**
+     * 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.
+     *
+     * @returns True if results were found, false otherwise
+     */
+    queryNextPage(): Promise<boolean>;
+    /**
+     * Resets the query to start from the beginning
+     */
+    reset(): void;
+}
+//# sourceMappingURL=pagedQuery.d.ts.map

package/dist/pagedQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagedQuery.d.ts","sourceRoot":"","sources":["../src/pagedQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EACV,gBAAgB,EAEhB,OAAO,EAGR,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAWjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/pagedQuery.js

@@ -0,0 +1,254 @@
+/**
+ * Cursor configuration for different table types
+ */
+const EVENT_CURSOR_COLUMNS = [
+    { name: 'blockNumber', sortOrder: 'DESC' },
+    { name: 'transactionIndex', sortOrder: 'DESC' },
+    { 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).
+ *
+ * @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',
+ *   sortOrder: 'DESC',
+ *   columns: ['blockNumber', 'transactionIndex', 'logIndex', 'group', 'member'],
+ *   filter: [{ Type: 'FilterPredicate', FilterType: 'Equals', Column: 'group', Value: '0x...' }],
+ *   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
+ * });
+ * ```
+ */
+export class PagedQuery {
+    params;
+    client;
+    rowTransformer;
+    cursorColumns;
+    orderColumns;
+    get currentPage() {
+        return this._currentPage;
+    }
+    _currentPage;
+    constructor(client, params, rowTransformer) {
+        this.client = client;
+        this.params = params;
+        this.rowTransformer = rowTransformer || params.rowTransformer;
+        this.orderColumns = params.orderColumns;
+        // Determine cursor columns based on table type
+        this.cursorColumns = params.cursorColumns || this.buildEventCursorColumns();
+    }
+    /**
+     * Builds cursor columns for event-based tables
+     */
+    buildEventCursorColumns() {
+        const columns = EVENT_CURSOR_COLUMNS.map(col => ({
+            ...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.
+     */
+    buildOrderBy() {
+        if (this.orderColumns && this.orderColumns.length > 0) {
+            return this.orderColumns;
+        }
+        return this.cursorColumns.map(col => ({
+            Column: col.name,
+            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
+     */
+    rowsToObjects(response) {
+        const { columns, rows } = response;
+        return rows.map(row => {
+            const rowObj = {};
+            columns.forEach((col, index) => {
+                rowObj[col] = row[index];
+            });
+            return this.rowTransformer ? this.rowTransformer(rowObj) : rowObj;
+        });
+    }
+    /**
+     * 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.
+     *
+     * @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,
+            Order: this.buildOrderBy(),
+            Limit: this.params.limit,
+        };
+        const response = await this.client.call('circles_query', [queryParams]);
+        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,
+            results,
+        };
+        return results.length > 0;
+    }
+    /**
+     * Resets the query to start from the beginning
+     */
+    reset() {
+        this._currentPage = undefined;
+    }
+}

package/dist/rpc.d.ts

@@ -0,0 +1,61 @@
+import { RpcClient } from './client';
+import { PathfinderMethods, QueryMethods, TrustMethods, BalanceMethods, AvatarMethods, ProfileMethods, TokenMethods, InvitationMethods, TransactionMethods, GroupMethods } from './methods';
+/**
+ * Main RPC class for Circles protocol RPC interactions
+ *
+ * @example
+ * ```typescript
+ * // Use default RPC endpoint
+ * const rpc = new CirclesRpc();
+ *
+ * // Use custom RPC endpoint
+ * const rpc = new CirclesRpc('https://rpc.circlesubi.network/');
+ *
+ * // Find a path
+ * const path = await rpc.pathfinder.findPath({
+ *   Source: '0x749c930256b47049cb65adcd7c25e72d5de44b3b',
+ *   Sink: '0xde374ece6fa50e781e81aac78e811b33d16912c7',
+ *   TargetFlow: '99999999999999999999999999999999999'
+ * });
+ *
+ * // Query trust relations
+ * const trustRelations = await rpc.query.query({
+ *   Namespace: 'V_CrcV2',
+ *   Table: 'TrustRelations',
+ *   Columns: [],
+ *   Filter: [],
+ *   Order: []
+ * });
+ *
+ * // Get profile
+ * const profile = await rpc.profile.getProfileByAddress('0xc3a1428c04c426cdf513c6fc8e09f55ddaf50cd7');
+ * ```
+ */
+export declare class CirclesRpc {
+    readonly client: RpcClient;
+    readonly pathfinder: PathfinderMethods;
+    readonly query: QueryMethods;
+    readonly trust: TrustMethods;
+    readonly balance: BalanceMethods;
+    readonly avatar: AvatarMethods;
+    readonly profile: ProfileMethods;
+    readonly token: TokenMethods;
+    readonly invitation: InvitationMethods;
+    readonly transaction: TransactionMethods;
+    readonly group: GroupMethods;
+    /**
+     * Create a new CirclesRpc instance
+     *
+     * @param rpcUrl RPC URL to use (defaults to https://rpc.circlesubi.network/)
+     */
+    constructor(rpcUrl?: string);
+    /**
+     * Update the RPC URL
+     */
+    setRpcUrl(rpcUrl: string): void;
+    /**
+     * Get the current RPC URL
+     */
+    getRpcUrl(): string;
+}
+//# sourceMappingURL=rpc.d.ts.map

package/dist/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACb,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,UAAU;IACrB,SAAgB,MAAM,EAAE,SAAS,CAAC;IAClC,SAAgB,UAAU,EAAE,iBAAiB,CAAC;IAC9C,SAAgB,KAAK,EAAE,YAAY,CAAC;IACpC,SAAgB,KAAK,EAAE,YAAY,CAAC;IACpC,SAAgB,OAAO,EAAE,cAAc,CAAC;IACxC,SAAgB,MAAM,EAAE,aAAa,CAAC;IACtC,SAAgB,OAAO,EAAE,cAAc,CAAC;IACxC,SAAgB,KAAK,EAAE,YAAY,CAAC;IACpC,SAAgB,UAAU,EAAE,iBAAiB,CAAC;IAC9C,SAAgB,WAAW,EAAE,kBAAkB,CAAC;IAChD,SAAgB,KAAK,EAAE,YAAY,CAAC;IAEpC;;;;OAIG;gBACS,MAAM,GAAE,MAA0C;IAe9D;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B;;OAEG;IACH,SAAS,IAAI,MAAM;CAGpB"}