@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

package/dist/debugger/source/dar-source-map-metadata.d.ts

@@ -0,0 +1,26 @@
+import { SourceMappingPrecision } from "./source-mapping-precision.js";
+export interface DarSourceMapMetadataExecutable {
+    packageId: string;
+    moduleName: string;
+    definitionName: string;
+    path: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    precision?: SourceMappingPrecision;
+    entrypointKind?: "create" | "exercise";
+    templateName?: string;
+    choiceName?: string;
+    choiceArgumentFieldName?: string;
+}
+export declare class DarSourceMapMetadata {
+    readonly packageId?: string;
+    readonly importedPackages: readonly string[];
+    readonly executables: readonly DarSourceMapMetadataExecutable[];
+    constructor(init?: {
+        packageId?: string;
+        importedPackages?: readonly string[];
+        executables?: readonly DarSourceMapMetadataExecutable[];
+    });
+}

package/dist/debugger/source/dar-source-map-metadata.js

@@ -0,0 +1,10 @@
+export class DarSourceMapMetadata {
+    packageId;
+    importedPackages;
+    executables;
+    constructor(init) {
+        this.packageId = init?.packageId;
+        this.importedPackages = init?.importedPackages ?? [];
+        this.executables = init?.executables ?? [];
+    }
+}

package/dist/debugger/source/source-coverage-validator.d.ts

@@ -0,0 +1,8 @@
+import { SourceIndexedCompilation } from "./source-indexed-compilation.js";
+export declare class SourceCoverageValidator {
+    static validateOrThrow(indexedCompilation: SourceIndexedCompilation, requiredSymbols: readonly {
+        packageId: string;
+        moduleName: string;
+        definitionName: string;
+    }[]): void;
+}

package/dist/debugger/source/source-coverage-validator.js

@@ -0,0 +1,16 @@
+import { ReplaySourceMapException } from "../errors/replay-source-map.exception.js";
+export class SourceCoverageValidator {
+    static validateOrThrow(indexedCompilation, requiredSymbols) {
+        for (const symbol of requiredSymbols) {
+            try {
+                indexedCompilation.getDefinitionSourceOrThrow(symbol.packageId, symbol.moduleName, symbol.definitionName);
+            }
+            catch (error) {
+                if (error instanceof ReplaySourceMapException) {
+                    throw error;
+                }
+                throw new ReplaySourceMapException(`failed to validate source coverage for '${symbol.packageId}::${symbol.moduleName}::${symbol.definitionName}'`);
+            }
+        }
+    }
+}

package/dist/debugger/source/source-indexed-compilation.d.ts

@@ -0,0 +1,45 @@
+import { DamlLfCompilation } from "../../daml-lf/daml-lf-compilation.js";
+import { DarSourceBundle } from "../../daml-lf/container/dar-source-bundle.js";
+import { DamlLfExpression } from "../../daml-lf/model/daml-lf-expression.js";
+import { SourceMappingPrecision } from "./source-mapping-precision.js";
+export interface IndexedDefinitionSource {
+    packageId: string;
+    moduleName: string;
+    definitionName: string;
+    path: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    precision: SourceMappingPrecision;
+}
+export interface IndexedExecutableSource extends IndexedDefinitionSource {
+    entrypointKind?: "create" | "exercise";
+    templateName?: string;
+    choiceName?: string;
+    choiceArgumentFieldName?: string;
+}
+export interface IndexedExpressionSource {
+    path: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+export declare class SourceIndexedCompilation {
+    readonly compilation: DamlLfCompilation;
+    private readonly definitionSources;
+    private readonly moduleSources;
+    private readonly expressionSources;
+    private constructor();
+    static createOrThrow(compilation: DamlLfCompilation, sourceBundles: readonly DarSourceBundle[]): SourceIndexedCompilation;
+    getDefinitionSourceOrThrow(packageId: string, moduleName: string, definitionName: string): IndexedExecutableSource;
+    getModuleSourceOrThrow(packageId: string, moduleName: string): IndexedDefinitionSource;
+    getExecutableSources(): readonly IndexedExecutableSource[];
+    findExecutableSourceAt(path: string, line: number, column: number): IndexedExecutableSource | undefined;
+    getExpressionSource(expression: DamlLfExpression): IndexedExpressionSource | undefined;
+    private containsSourceLocation;
+    private compareSourceSpecificity;
+    private static createDefinitionKey;
+    private static createModuleKey;
+}

package/dist/debugger/source/source-indexed-compilation.js

@@ -0,0 +1,110 @@
+import { getDamlLfExpressionAtPath } from "../../daml-lf/model/daml-lf-expression-path.js";
+import { ReplaySourceMapException } from "../errors/replay-source-map.exception.js";
+import { SourceMappingPrecision, } from "./source-mapping-precision.js";
+export class SourceIndexedCompilation {
+    compilation;
+    definitionSources = new Map();
+    moduleSources = new Map();
+    expressionSources = new Map();
+    constructor(compilation) {
+        this.compilation = compilation;
+    }
+    static createOrThrow(compilation, sourceBundles) {
+        const indexed = new SourceIndexedCompilation(compilation);
+        for (const bundle of sourceBundles) {
+            for (const executable of bundle.metadata.executables) {
+                const source = {
+                    packageId: executable.packageId,
+                    moduleName: executable.moduleName,
+                    definitionName: executable.definitionName,
+                    path: executable.path,
+                    startLine: executable.startLine,
+                    startColumn: executable.startColumn,
+                    endLine: executable.endLine,
+                    endColumn: executable.endColumn,
+                    precision: executable.precision
+                        ?? SourceMappingPrecision.fallback,
+                    entrypointKind: executable.entrypointKind,
+                    templateName: executable.templateName,
+                    choiceName: executable.choiceName,
+                    choiceArgumentFieldName: executable.choiceArgumentFieldName,
+                };
+                indexed.definitionSources.set(SourceIndexedCompilation.createDefinitionKey(executable.packageId, executable.moduleName, executable.definitionName), source);
+                indexed.moduleSources.set(SourceIndexedCompilation.createModuleKey(executable.packageId, executable.moduleName), source);
+            }
+            for (const expressionLocation of bundle.metadata.expressionLocations) {
+                if (!Array.isArray(expressionLocation.expressionPath)) {
+                    throw new ReplaySourceMapException(`expression source mapping for '${expressionLocation.packageId}::${expressionLocation.moduleName}::${expressionLocation.definitionName}' is missing its expression path`);
+                }
+                const definition = compilation.getValueDefinitionOrThrow(expressionLocation.packageId, expressionLocation.moduleName, expressionLocation.definitionName);
+                const expression = getDamlLfExpressionAtPath(definition.expression, expressionLocation.expressionPath);
+                if (expression === undefined) {
+                    throw new ReplaySourceMapException(`invalid expression path for '${expressionLocation.packageId}::${expressionLocation.moduleName}::${expressionLocation.definitionName}'`);
+                }
+                indexed.expressionSources.set(expression, {
+                    path: expressionLocation.path,
+                    startLine: expressionLocation.startLine,
+                    startColumn: expressionLocation.startColumn,
+                    endLine: expressionLocation.endLine,
+                    endColumn: expressionLocation.endColumn,
+                });
+            }
+        }
+        return indexed;
+    }
+    getDefinitionSourceOrThrow(packageId, moduleName, definitionName) {
+        const source = this.definitionSources.get(SourceIndexedCompilation.createDefinitionKey(packageId, moduleName, definitionName));
+        if (source === undefined) {
+            throw new ReplaySourceMapException(`missing source mapping for '${packageId}::${moduleName}::${definitionName}'`);
+        }
+        return source;
+    }
+    getModuleSourceOrThrow(packageId, moduleName) {
+        const source = this.moduleSources.get(SourceIndexedCompilation.createModuleKey(packageId, moduleName));
+        if (source === undefined) {
+            throw new ReplaySourceMapException(`missing source mapping for module '${packageId}::${moduleName}'`);
+        }
+        return source;
+    }
+    getExecutableSources() {
+        return [...this.definitionSources.values()];
+    }
+    findExecutableSourceAt(path, line, column) {
+        return this.getExecutableSources()
+            .filter((source) => source.path === path
+            && this.containsSourceLocation(source, line, column))
+            .sort((left, right) => this.compareSourceSpecificity(left, right))
+            .at(0);
+    }
+    getExpressionSource(expression) {
+        return this.expressionSources.get(expression);
+    }
+    containsSourceLocation(source, line, column) {
+        const startsBeforeOrAt = source.startLine < line
+            || (source.startLine === line && source.startColumn <= column);
+        const endsAfterOrAt = source.endLine > line
+            || (source.endLine === line && source.endColumn >= column);
+        return startsBeforeOrAt && endsAfterOrAt;
+    }
+    compareSourceSpecificity(left, right) {
+        if (left.startLine !== right.startLine) {
+            return right.startLine - left.startLine;
+        }
+        if (left.startColumn !== right.startColumn) {
+            return right.startColumn - left.startColumn;
+        }
+        if (left.endLine !== right.endLine) {
+            return left.endLine - right.endLine;
+        }
+        if (left.endColumn !== right.endColumn) {
+            return left.endColumn - right.endColumn;
+        }
+        return 0;
+    }
+    static createDefinitionKey(packageId, moduleName, definitionName) {
+        return `${packageId}::${moduleName}::${definitionName}`;
+    }
+    static createModuleKey(packageId, moduleName) {
+        return `${packageId}::${moduleName}`;
+    }
+}

package/dist/debugger/source/source-mapping-precision.d.ts

@@ -0,0 +1,5 @@
+export declare const SourceMappingPrecision: {
+    readonly exact: "exact";
+    readonly fallback: "fallback";
+};
+export type SourceMappingPrecision = (typeof SourceMappingPrecision)[keyof typeof SourceMappingPrecision];

package/dist/debugger/source/source-mapping-precision.js

@@ -0,0 +1,4 @@
+export const SourceMappingPrecision = {
+    exact: "exact",
+    fallback: "fallback",
+};

package/dist/index.d.ts

@@ -1,4 +1,14 @@
 export { CantonClient } from "./client/canton-client.js";
+export { CantonManager } from "./query/canton-manager.js";
+export { QuerySource } from "./query/query-source.js";
+export { MemoryQueryCache } from "./query/cache/memory-query-cache.js";
+export { QueryCapabilityError } from "./query/errors/query-capability-error.js";
+export { PqsQueryError } from "./query/errors/pqs-query-error.js";
+export { PqsSchemaProfileError } from "./query/errors/pqs-schema-profile-error.js";
+export type { CantonManagerOptions, PqsQueryOptions, QueryCacheOptions, } from "./query/canton-manager-options.js";
+export type { QueryCacheStore } from "./query/cache/query-cache-store.js";
+export type { ContractFindManyArgs, ContractFindUniqueArgs, ContractCountArgs, ContractRow, ContractTypeRow, EventRow, ExerciseRow, ExerciseTypeRow, PackageRow, TransactionRow, WatermarkRow, RowWhere, RowSelect, RowOrderBy, } from "./query/model-types.js";
+export type { QueryClient, QueryDelegate, QueryCollectionDelegate } from "./query/query-client.js";
 export { CantonHashingClient } from "./client/canton-hashing-client.js";
 export { CantonClientOptions } from "./client/canton-client-options.js";
 export { ExternalPartyActivationClient } from "./client/external-party-activation-client.js";
@@ -72,6 +82,8 @@ export { CommitmentTimeRange } from "./core/types/commitment-time-range.js";
 export { CounterParticipantInfo } from "./core/types/counter-participant-info.js";
 export { ContractArchived } from "./core/types/contract-archived.js";
 export { ContractCreated } from "./core/types/contract-created.js";
+export { DamlNumeric } from "./core/types/daml-numeric.js";
+export { DamlParty } from "./core/types/daml-party.js";
 export { EventStreamKind } from "./core/types/event-stream-kind.js";
 export { UserRightKind } from "./core/types/user-right-kind.js";
 export { IdentityProviderConfig } from "./core/types/identity-provider-config.js";
@@ -186,7 +198,13 @@ export { ExerciseByKeyCommand } from "./core/types/commands/exercise-by-key-comm
 export { ExerciseCommand } from "./core/types/commands/exercise-command.js";
 export type { LedgerCommand } from "./core/types/commands/ledger-command.js";
 export { AddTopologyTransactionsRequest } from "./core/types/requests/add-topology-transactions-request.js";
+export { CreateDecentralizedPartyRequest } from "./core/types/requests/create-decentralized-party-request.js";
+export type { DecentralizedPartyKey, DecentralizedPartySigner, DecentralizedPartySigningRequest } from "./core/types/requests/create-decentralized-party-request.js";
+export { FinalizeDecentralizedPartyRequest, PreparedDecentralizedParty } from "./core/types/requests/finalize-decentralized-party-request.js";
+export type { DecentralizedPartyDetachedSignature, PreparedDecentralizedPartySigningRequest } from "./core/types/requests/finalize-decentralized-party-request.js";
 export { AllocateExternalPartyRequest } from "./core/types/requests/allocate-external-party-request.js";
+export { CreateExternalPartyRequest, } from "./core/types/requests/create-external-party-request.js";
+export type { ExternalPartySigner, ExternalPartySigningRequest, ExternalPartySigningResult, ExternalPartySigningPayloadKind, } from "./core/types/requests/create-external-party-request.js";
 export { AllocatePartyRequest } from "./core/types/requests/allocate-party-request.js";
 export { AddPartyAsyncArguments } from "./core/types/requests/add-party-async-request.js";
 export { AddPartyAsyncRequest } from "./core/types/requests/add-party-async-request.js";
@@ -384,6 +402,8 @@ export { ValidationError } from "./core/errors/validation-error.js";
 export { AuthenticationError } from "./core/errors/authentication-error.js";
 export { AuthorizationError } from "./core/errors/authorization-error.js";
 export { TransportError } from "./core/errors/transport-error.js";
+export { GrpcTransportError } from "./core/errors/grpc-transport-error.js";
+export type { GrpcErrorMetadata, GrpcStatusDetails, } from "./core/errors/grpc-transport-error.js";
 export { SigningError } from "./core/errors/signing-error.js";
 export { TimeoutError } from "./core/errors/timeout-error.js";
 export { ConflictError } from "./core/errors/conflict-error.js";

package/dist/index.js

@@ -1,4 +1,10 @@
 export { CantonClient } from "./client/canton-client.js";
+export { CantonManager } from "./query/canton-manager.js";
+export { QuerySource } from "./query/query-source.js";
+export { MemoryQueryCache } from "./query/cache/memory-query-cache.js";
+export { QueryCapabilityError } from "./query/errors/query-capability-error.js";
+export { PqsQueryError } from "./query/errors/pqs-query-error.js";
+export { PqsSchemaProfileError } from "./query/errors/pqs-schema-profile-error.js";
 export { CantonHashingClient } from "./client/canton-hashing-client.js";
 export { CantonClientOptions } from "./client/canton-client-options.js";
 export { ExternalPartyActivationClient } from "./client/external-party-activation-client.js";
@@ -68,6 +74,8 @@ export { CommitmentTimeRange } from "./core/types/commitment-time-range.js";
 export { CounterParticipantInfo } from "./core/types/counter-participant-info.js";
 export { ContractArchived } from "./core/types/contract-archived.js";
 export { ContractCreated } from "./core/types/contract-created.js";
+export { DamlNumeric } from "./core/types/daml-numeric.js";
+export { DamlParty } from "./core/types/daml-party.js";
 export { EventStreamKind } from "./core/types/event-stream-kind.js";
 export { UserRightKind } from "./core/types/user-right-kind.js";
 export { IdentityProviderConfig } from "./core/types/identity-provider-config.js";
@@ -180,7 +188,10 @@ export { CreateCommand } from "./core/types/commands/create-command.js";
 export { ExerciseByKeyCommand } from "./core/types/commands/exercise-by-key-command.js";
 export { ExerciseCommand } from "./core/types/commands/exercise-command.js";
 export { AddTopologyTransactionsRequest } from "./core/types/requests/add-topology-transactions-request.js";
+export { CreateDecentralizedPartyRequest } from "./core/types/requests/create-decentralized-party-request.js";
+export { FinalizeDecentralizedPartyRequest, PreparedDecentralizedParty } from "./core/types/requests/finalize-decentralized-party-request.js";
 export { AllocateExternalPartyRequest } from "./core/types/requests/allocate-external-party-request.js";
+export { CreateExternalPartyRequest, } from "./core/types/requests/create-external-party-request.js";
 export { AllocatePartyRequest } from "./core/types/requests/allocate-party-request.js";
 export { AddPartyAsyncArguments } from "./core/types/requests/add-party-async-request.js";
 export { AddPartyAsyncRequest } from "./core/types/requests/add-party-async-request.js";
@@ -374,6 +385,7 @@ export { ValidationError } from "./core/errors/validation-error.js";
 export { AuthenticationError } from "./core/errors/authentication-error.js";
 export { AuthorizationError } from "./core/errors/authorization-error.js";
 export { TransportError } from "./core/errors/transport-error.js";
+export { GrpcTransportError } from "./core/errors/grpc-transport-error.js";
 export { SigningError } from "./core/errors/signing-error.js";
 export { TimeoutError } from "./core/errors/timeout-error.js";
 export { ConflictError } from "./core/errors/conflict-error.js";

package/dist/query/cache/memory-query-cache.d.ts

@@ -0,0 +1,9 @@
+import { QueryCacheStore } from "./query-cache-store.js";
+export declare class MemoryQueryCache implements QueryCacheStore {
+    private readonly now;
+    private readonly entries;
+    constructor(now?: () => number);
+    getAsync<T>(key: string): Promise<T | undefined>;
+    setAsync<T>(key: string, value: T, ttlMs: number): Promise<void>;
+    deleteAsync(key: string): Promise<void>;
+}

package/dist/query/cache/memory-query-cache.js

@@ -0,0 +1,24 @@
+export class MemoryQueryCache {
+    now;
+    entries = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    async getAsync(key) {
+        const entry = this.entries.get(key);
+        if (entry === undefined) {
+            return undefined;
+        }
+        else if (entry.expiresAt <= this.now()) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async setAsync(key, value, ttlMs) {
+        this.entries.set(key, { expiresAt: this.now() + ttlMs, value });
+    }
+    async deleteAsync(key) {
+        this.entries.delete(key);
+    }
+}

package/dist/query/cache/query-cache-store.d.ts

@@ -0,0 +1,5 @@
+export interface QueryCacheStore {
+    getAsync<T>(key: string): Promise<T | undefined>;
+    setAsync<T>(key: string, value: T, ttlMs: number): Promise<void>;
+    deleteAsync(key: string): Promise<void>;
+}

package/dist/query/cache/query-cache-store.js

@@ -0,0 +1 @@
+export {};

package/dist/query/canton-manager-options.d.ts

@@ -0,0 +1,17 @@
+import { CantonClientOptions } from "../client/canton-client-options.js";
+import { QueryCacheStore } from "./cache/query-cache-store.js";
+import { QuerySource } from "./query-source.js";
+export interface PqsQueryOptions {
+    readonly connectionString: string;
+    readonly schema?: string;
+}
+export interface QueryCacheOptions {
+    readonly store: QueryCacheStore;
+    readonly ttlMs: number;
+}
+export interface CantonManagerOptions {
+    readonly grpc: CantonClientOptions;
+    readonly querySource: QuerySource;
+    readonly pqs?: PqsQueryOptions;
+    readonly cache?: QueryCacheOptions;
+}

package/dist/query/canton-manager-options.js

@@ -0,0 +1 @@
+export {};

package/dist/query/canton-manager.d.ts

@@ -0,0 +1,11 @@
+import { CantonClient } from "../client/canton-client.js";
+import { CantonManagerOptions } from "./canton-manager-options.js";
+import { QueryClient } from "./query-client.js";
+export declare class CantonManager {
+    readonly grpc: CantonClient;
+    readonly query: QueryClient;
+    private readonly pqsPool?;
+    private disposed;
+    constructor(options: CantonManagerOptions);
+    disposeAsync(): Promise<void>;
+}

package/dist/query/canton-manager.js

@@ -0,0 +1,42 @@
+import { CantonClient } from "../client/canton-client.js";
+import { TransportKind } from "../core/types/transport-kind.js";
+import { ValidationError } from "../core/errors/validation-error.js";
+import { GrpcContractQueryClient } from "./grpc/grpc-contract-query-client.js";
+import { PqsPool } from "./pqs/pqs-pool.js";
+import { PqsQueryClient } from "./pqs/pqs-query-client.js";
+import { PqsSchemaProfileV1, validatePqsSchemaAsync } from "./pqs/pqs-schema-profile.js";
+import { QuerySource } from "./query-source.js";
+export class CantonManager {
+    grpc;
+    query;
+    pqsPool;
+    disposed = false;
+    constructor(options) {
+        if (options.grpc.transportKind !== TransportKind.grpc) {
+            throw new ValidationError("CantonManager requires grpc transport for writes.");
+        }
+        else if (options.querySource === QuerySource.grpc && options.pqs !== undefined) {
+            throw new ValidationError("PQS options require QuerySource.pqs.");
+        }
+        else if (options.querySource === QuerySource.pqs && options.pqs === undefined) {
+            throw new ValidationError("QuerySource.pqs requires PQS options.");
+        }
+        this.grpc = new CantonClient(options.grpc);
+        if (options.querySource === QuerySource.pqs) {
+            this.pqsPool = PqsPool.create(options.pqs.connectionString);
+            const profile = new PqsSchemaProfileV1(options.pqs.schema);
+            this.query = new PqsQueryClient(this.pqsPool.pool, profile, validatePqsSchemaAsync(this.pqsPool.pool, profile));
+        }
+        else {
+            this.query = new GrpcContractQueryClient(this.grpc.stateService, options.cache?.store, options.cache?.ttlMs, options.grpc.ledgerEndpoint ?? "ledger");
+        }
+    }
+    async disposeAsync() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        await this.pqsPool?.disposeAsync();
+        await this.grpc.disposeAsync();
+    }
+}

package/dist/query/errors/pqs-query-error.d.ts

@@ -0,0 +1,10 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class PqsQueryError extends CantonError {
+    readonly operation: string;
+    readonly code?: string;
+    constructor(init: {
+        operation: string;
+        code?: string;
+        cause?: unknown;
+    });
+}

package/dist/query/errors/pqs-query-error.js

@@ -0,0 +1,11 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class PqsQueryError extends CantonError {
+    operation;
+    code;
+    constructor(init) {
+        super(`PQS query ${init.operation} failed${init.code === undefined ? "" : ` (${init.code})`}.`);
+        this.operation = init.operation;
+        this.code = init.code;
+        void init.cause;
+    }
+}

package/dist/query/errors/pqs-schema-profile-error.d.ts

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class PqsSchemaProfileError extends CantonError {
+}

package/dist/query/errors/pqs-schema-profile-error.js

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class PqsSchemaProfileError extends CantonError {
+}

package/dist/query/errors/query-capability-error.d.ts

@@ -0,0 +1,7 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+import { QuerySource } from "../query-source.js";
+export declare class QueryCapabilityError extends CantonError {
+    readonly source: QuerySource;
+    readonly operation: string;
+    constructor(source: QuerySource, operation: string);
+}

package/dist/query/errors/query-capability-error.js

@@ -0,0 +1,10 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class QueryCapabilityError extends CantonError {
+    source;
+    operation;
+    constructor(source, operation) {
+        super(`Query operation ${operation} is not supported by ${source}.`);
+        this.source = source;
+        this.operation = operation;
+    }
+}

package/dist/query/grpc/grpc-contract-query-client.d.ts

@@ -0,0 +1,32 @@
+import { StateServiceClient } from "../../services/state/state-service-client.js";
+import { QueryCacheStore } from "../cache/query-cache-store.js";
+import { ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractRow } from "../model-types.js";
+import { QueryClient } from "../query-client.js";
+import { QuerySource } from "../query-source.js";
+type ActiveContractsReader = Pick<StateServiceClient, "getActiveContractsPageAsync">;
+export declare class GrpcContractQueryClient implements QueryClient {
+    private readonly stateService;
+    private readonly cache;
+    private readonly cacheTtlMs;
+    private readonly cacheScope;
+    readonly source = QuerySource.grpc;
+    readonly contracts: {
+        findMany: (args?: ContractFindManyArgs) => Promise<readonly ContractRow[]>;
+        findUnique: (args: ContractFindUniqueArgs) => Promise<ContractRow>;
+        count: (args?: ContractCountArgs) => Promise<number>;
+        aggregate: () => Promise<never>;
+    };
+    readonly contractTypes: QueryClient["contractTypes"];
+    readonly events: QueryClient["events"];
+    readonly exercises: QueryClient["exercises"];
+    readonly exerciseTypes: QueryClient["exerciseTypes"];
+    readonly packages: QueryClient["packages"];
+    readonly transactions: QueryClient["transactions"];
+    readonly watermark: QueryClient["watermark"];
+    constructor(stateService: ActiveContractsReader, cache: QueryCacheStore | undefined, cacheTtlMs: number | undefined, cacheScope: string);
+    $queryRaw<TRow>(_sql: string, _values?: readonly unknown[]): Promise<readonly TRow[]>;
+    private findManyAsync;
+    private unsupported;
+    private readSnapshotAsync;
+}
+export {};