@distrohelena/canton-typescript-sdk 0.1.0

package/dist/transports/grpc/mappers/participant-inspection-mapper.js

@@ -0,0 +1,244 @@
+import { CounterParticipantInfo } from "../../../core/types/counter-participant-info.js";
+import { CommitmentInterval } from "../../../core/types/commitment-interval.js";
+import { ReceivedAcsCommitment } from "../../../core/types/received-acs-commitment.js";
+import { ReceivedAcsCommitmentPerSynchronizer } from "../../../core/types/received-acs-commitment-per-synchronizer.js";
+import { ReceivedAcsCommitmentState } from "../../../core/types/received-acs-commitment-state.js";
+import { SentAcsCommitment } from "../../../core/types/sent-acs-commitment.js";
+import { SentAcsCommitmentPerSynchronizer } from "../../../core/types/sent-acs-commitment-per-synchronizer.js";
+import { SentAcsCommitmentState } from "../../../core/types/sent-acs-commitment-state.js";
+import { SlowCounterParticipantSynchronizerConfig } from "../../../core/types/slow-counter-participant-synchronizer-config.js";
+import { CountInFlightResponse } from "../../../core/types/responses/count-in-flight-response.js";
+import { GetConfigForSlowCounterParticipantsResponse } from "../../../core/types/responses/get-config-for-slow-counter-participants-response.js";
+import { GetIntervalsBehindForCounterParticipantsResponse } from "../../../core/types/responses/get-intervals-behind-for-counter-participants-response.js";
+import { InspectCommitmentContractsResponse } from "../../../core/types/responses/inspect-commitment-contracts-response.js";
+import { LookupReceivedAcsCommitmentsResponse } from "../../../core/types/responses/lookup-received-acs-commitments-response.js";
+import { LookupSentAcsCommitmentsResponse } from "../../../core/types/responses/lookup-sent-acs-commitments-response.js";
+import { LookupOffsetByTimeResponse } from "../../../core/types/responses/lookup-offset-by-time-response.js";
+import { OpenCommitmentResponse } from "../../../core/types/responses/open-commitment-response.js";
+import { ReceivedCommitmentState, SentCommitmentState, } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/participant_inspection_service.js";
+import { mapGrpcTimestamp, mapSdkDuration, mapSdkTimestamp } from "./topology-common-mapper.js";
+export function mapGrpcLookupOffsetByTimeRequest(request) {
+    return {
+        timestamp: mapGrpcTimestamp(request.timestamp),
+    };
+}
+export function mapGrpcLookupOffsetByTime(payload) {
+    return new LookupOffsetByTimeResponse({
+        offset: payload?.offset,
+    });
+}
+export function mapGrpcOpenCommitmentRequest(request) {
+    return {
+        commitment: request.commitment,
+        physicalSynchronizerId: request.physicalSynchronizerId,
+        computedForCounterParticipantUid: request.computedForCounterParticipantUid,
+        periodEndTick: mapGrpcTimestamp(request.periodEndTick),
+    };
+}
+export function mapGrpcOpenCommitment(payload) {
+    return new OpenCommitmentResponse({
+        chunk: payload?.chunk,
+    });
+}
+export function mapGrpcInspectCommitmentContractsRequest(request) {
+    return {
+        cids: request.cids.map((item) => new Uint8Array(item)),
+        expectedSynchronizerId: request.expectedSynchronizerId,
+        timestamp: mapGrpcTimestamp(request.timestamp),
+        downloadPayload: request.downloadPayload,
+    };
+}
+export function mapGrpcInspectCommitmentContracts(payload) {
+    return new InspectCommitmentContractsResponse({
+        chunk: payload?.chunk,
+    });
+}
+export function mapGrpcCountInFlightRequest(request) {
+    return {
+        synchronizerId: request.synchronizerId,
+    };
+}
+export function mapGrpcCountInFlight(payload) {
+    return new CountInFlightResponse({
+        pendingSubmissions: payload?.pendingSubmissions ?? 0,
+        pendingTransactions: payload?.pendingTransactions ?? 0,
+    });
+}
+export function mapGrpcGetConfigForSlowCounterParticipantsRequest(request) {
+    return {
+        synchronizerIds: [...request.synchronizerIds],
+    };
+}
+export function mapGrpcGetConfigForSlowCounterParticipants(payload) {
+    return new GetConfigForSlowCounterParticipantsResponse({
+        configs: (payload?.configs ?? []).map((item) => mapGrpcSlowCounterParticipantSynchronizerConfig(item)),
+    });
+}
+export function mapGrpcGetIntervalsBehindForCounterParticipantsRequest(request) {
+    return {
+        counterParticipantIds: [...request.counterParticipantIds],
+        synchronizerIds: [...request.synchronizerIds],
+        threshold: request.threshold,
+    };
+}
+export function mapGrpcGetIntervalsBehindForCounterParticipants(payload) {
+    return new GetIntervalsBehindForCounterParticipantsResponse({
+        intervalsBehind: (payload?.intervalsBehind ?? []).map((item) => mapGrpcCounterParticipantInfo(item)),
+    });
+}
+export function mapGrpcLookupSentAcsCommitmentsRequest(request) {
+    return {
+        timeRanges: request.timeRanges.map((item) => mapGrpcSynchronizerTimeRange(item)),
+        counterParticipantIds: [...request.counterParticipantIds],
+        commitmentState: request.commitmentState.map((item) => mapGrpcSentCommitmentState(item)),
+        verbose: request.verbose,
+    };
+}
+export function mapGrpcLookupSentAcsCommitments(payload) {
+    return new LookupSentAcsCommitmentsResponse({
+        sent: (payload?.sent ?? []).map((item) => mapGrpcSentAcsCommitmentPerSynchronizer(item)),
+    });
+}
+export function mapGrpcLookupReceivedAcsCommitmentsRequest(request) {
+    return {
+        timeRanges: request.timeRanges.map((item) => mapGrpcSynchronizerTimeRange(item)),
+        counterParticipantIds: [...request.counterParticipantIds],
+        commitmentState: request.commitmentState.map((item) => mapGrpcReceivedCommitmentState(item)),
+        verbose: request.verbose,
+    };
+}
+export function mapGrpcLookupReceivedAcsCommitments(payload) {
+    return new LookupReceivedAcsCommitmentsResponse({
+        received: (payload?.received ?? []).map((item) => mapGrpcReceivedAcsCommitmentPerSynchronizer(item)),
+    });
+}
+function mapGrpcSlowCounterParticipantSynchronizerConfig(payload) {
+    return new SlowCounterParticipantSynchronizerConfig({
+        synchronizerIds: [...(payload?.synchronizerIds ?? [])],
+        distinguishedParticipantUids: [
+            ...(payload?.distinguishedParticipantUids ?? []),
+        ],
+        thresholdDistinguished: payload?.thresholdDistinguished,
+        thresholdDefault: payload?.thresholdDefault,
+        participantUidsMetrics: [...(payload?.participantUidsMetrics ?? [])],
+    });
+}
+function mapGrpcCounterParticipantInfo(payload) {
+    return new CounterParticipantInfo({
+        counterParticipantUid: payload?.counterParticipantUid ?? "",
+        synchronizerId: payload?.synchronizerId ?? "",
+        intervalsBehind: payload?.intervalsBehind ?? "",
+        behindSince: mapSdkDuration(payload?.behindSince),
+        asOfSequencingTimestamp: mapSdkTimestamp(payload?.asOfSequencingTimestamp),
+    });
+}
+function mapGrpcSynchronizerTimeRange(range) {
+    return {
+        synchronizerId: range.synchronizerId,
+        interval: mapGrpcTimeRange(range.interval),
+    };
+}
+function mapGrpcTimeRange(range) {
+    if (range === undefined) {
+        return undefined;
+    }
+    return {
+        fromExclusive: mapGrpcTimestamp(range.fromExclusive),
+        toInclusive: mapGrpcTimestamp(range.toInclusive),
+    };
+}
+function mapGrpcSentAcsCommitmentPerSynchronizer(payload) {
+    return new SentAcsCommitmentPerSynchronizer({
+        synchronizerId: payload?.synchronizerId ?? "",
+        sent: (payload?.sent ?? []).map((item) => mapGrpcSentAcsCommitment(item)),
+    });
+}
+function mapGrpcSentAcsCommitment(payload) {
+    return new SentAcsCommitment({
+        interval: mapSdkCommitmentInterval(payload?.interval),
+        destCounterParticipantUid: payload?.destCounterParticipantUid ?? "",
+        ownCommitment: payload?.ownCommitment,
+        receivedCommitment: payload?.receivedCommitment,
+        state: mapSdkSentCommitmentState(payload?.state),
+    });
+}
+function mapGrpcReceivedAcsCommitmentPerSynchronizer(payload) {
+    return new ReceivedAcsCommitmentPerSynchronizer({
+        synchronizerId: payload?.synchronizerId ?? "",
+        received: (payload?.received ?? []).map((item) => mapGrpcReceivedAcsCommitment(item)),
+    });
+}
+function mapGrpcReceivedAcsCommitment(payload) {
+    return new ReceivedAcsCommitment({
+        interval: mapSdkCommitmentInterval(payload?.interval),
+        originCounterParticipantUid: payload?.originCounterParticipantUid ?? "",
+        receivedCommitment: payload?.receivedCommitment,
+        ownCommitment: payload?.ownCommitment,
+        state: mapSdkReceivedCommitmentState(payload?.state),
+    });
+}
+function mapSdkCommitmentInterval(payload) {
+    if (payload === undefined) {
+        return undefined;
+    }
+    return new CommitmentInterval({
+        startTickExclusive: mapSdkTimestamp(payload.startTickExclusive),
+        endTickInclusive: mapSdkTimestamp(payload.endTickInclusive),
+    });
+}
+function mapGrpcSentCommitmentState(value) {
+    switch (value) {
+        case SentAcsCommitmentState.match:
+            return SentCommitmentState.MATCH;
+        case SentAcsCommitmentState.mismatch:
+            return SentCommitmentState.MISMATCH;
+        case SentAcsCommitmentState.notCompared:
+            return SentCommitmentState.NOT_COMPARED;
+        case SentAcsCommitmentState.unspecified:
+        default:
+            return SentCommitmentState.UNSPECIFIED;
+    }
+}
+function mapSdkSentCommitmentState(value) {
+    switch (value) {
+        case SentCommitmentState.MATCH:
+            return SentAcsCommitmentState.match;
+        case SentCommitmentState.MISMATCH:
+            return SentAcsCommitmentState.mismatch;
+        case SentCommitmentState.NOT_COMPARED:
+            return SentAcsCommitmentState.notCompared;
+        case SentCommitmentState.UNSPECIFIED:
+        default:
+            return SentAcsCommitmentState.unspecified;
+    }
+}
+function mapGrpcReceivedCommitmentState(value) {
+    switch (value) {
+        case ReceivedAcsCommitmentState.match:
+            return ReceivedCommitmentState.MATCH;
+        case ReceivedAcsCommitmentState.mismatch:
+            return ReceivedCommitmentState.MISMATCH;
+        case ReceivedAcsCommitmentState.buffered:
+            return ReceivedCommitmentState.BUFFERED;
+        case ReceivedAcsCommitmentState.outstanding:
+            return ReceivedCommitmentState.OUTSTANDING;
+        case ReceivedAcsCommitmentState.unspecified:
+        default:
+            return ReceivedCommitmentState.UNSPECIFIED;
+    }
+}
+function mapSdkReceivedCommitmentState(value) {
+    switch (value) {
+        case ReceivedCommitmentState.MATCH:
+            return ReceivedAcsCommitmentState.match;
+        case ReceivedCommitmentState.MISMATCH:
+            return ReceivedAcsCommitmentState.mismatch;
+        case ReceivedCommitmentState.BUFFERED:
+            return ReceivedAcsCommitmentState.buffered;
+        case ReceivedCommitmentState.OUTSTANDING:
+            return ReceivedAcsCommitmentState.outstanding;
+        case ReceivedCommitmentState.UNSPECIFIED:
+        default:
+            return ReceivedAcsCommitmentState.unspecified;
+    }
+}

package/dist/transports/grpc/mappers/participant-party-management-mapper.d.ts

@@ -0,0 +1,6 @@
+import { GetHighestOffsetByTimestampRequest } from "../../../core/types/requests/get-highest-offset-by-timestamp-request.js";
+import { GetHighestOffsetByTimestampResponse } from "../../../core/types/responses/get-highest-offset-by-timestamp-response.js";
+import { GetHighestOffsetByTimestampRequest as GrpcGetHighestOffsetByTimestampRequest } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/party_management_service.js";
+import { GetHighestOffsetByTimestampResponse as GrpcGetHighestOffsetByTimestampResponse } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/party_management_service.js";
+export declare function mapGrpcGetHighestOffsetByTimestampRequest(request: GetHighestOffsetByTimestampRequest): GrpcGetHighestOffsetByTimestampRequest;
+export declare function mapGrpcGetHighestOffsetByTimestamp(payload: Partial<GrpcGetHighestOffsetByTimestampResponse>): GetHighestOffsetByTimestampResponse;

package/dist/transports/grpc/mappers/participant-party-management-mapper.js

@@ -0,0 +1,14 @@
+import { GetHighestOffsetByTimestampResponse } from "../../../core/types/responses/get-highest-offset-by-timestamp-response.js";
+import { mapGrpcTimestamp } from "./topology-common-mapper.js";
+export function mapGrpcGetHighestOffsetByTimestampRequest(request) {
+    return {
+        synchronizerId: request.synchronizerId,
+        timestamp: mapGrpcTimestamp(request.timestamp),
+        force: request.force,
+    };
+}
+export function mapGrpcGetHighestOffsetByTimestamp(payload) {
+    return new GetHighestOffsetByTimestampResponse({
+        ledgerOffset: payload.ledgerOffset ?? "",
+    });
+}

package/dist/transports/grpc/mappers/participant-repair-mapper.d.ts

@@ -0,0 +1,6 @@
+import { ListPendingOperationsRequest } from "../../../core/types/requests/list-pending-operations-request.js";
+import { ListPendingOperationsResponse } from "../../../core/types/responses/list-pending-operations-response.js";
+import { ListPendingOperationsRequest as GrpcListPendingOperationsRequest } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/participant_repair_service.js";
+import { ListPendingOperationsResponse as GrpcListPendingOperationsResponse } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/participant_repair_service.js";
+export declare function mapGrpcListPendingOperationsRequest(request: ListPendingOperationsRequest): GrpcListPendingOperationsRequest;
+export declare function mapGrpcListPendingOperations(payload: Partial<GrpcListPendingOperationsResponse>): ListPendingOperationsResponse;

package/dist/transports/grpc/mappers/participant-repair-mapper.js

@@ -0,0 +1,36 @@
+import { PendingOperationMetadata } from "../../../core/types/pending-operation-metadata.js";
+import { ListPendingOperationsResponse } from "../../../core/types/responses/list-pending-operations-response.js";
+export function mapGrpcListPendingOperationsRequest(request) {
+    return {
+        operationName: request.operationName,
+        filterSynchronizer: request.filterSynchronizerId === undefined
+            && request.filterPhysicalSynchronizerId === undefined
+            ? undefined
+            : {
+                kind: request.filterPhysicalSynchronizerId !== undefined
+                    ? {
+                        oneofKind: "physicalId",
+                        physicalId: request.filterPhysicalSynchronizerId,
+                    }
+                    : {
+                        oneofKind: "id",
+                        id: request.filterSynchronizerId ?? "",
+                    },
+            },
+        filterOperationKey: request.filterOperationKey,
+    };
+}
+export function mapGrpcListPendingOperations(payload) {
+    return new ListPendingOperationsResponse({
+        pendingOperations: (payload.pendingOperations ?? []).map((item) => new PendingOperationMetadata({
+            operationName: item.operationName,
+            operationKey: item.operationKey,
+            synchronizerId: item.synchronizer?.kind.oneofKind === "id"
+                ? item.synchronizer.kind.id
+                : undefined,
+            physicalSynchronizerId: item.synchronizer?.kind.oneofKind === "physicalId"
+                ? item.synchronizer.kind.physicalId
+                : undefined,
+        })),
+    });
+}

package/dist/transports/grpc/mappers/participant-status-mapper.d.ts

@@ -0,0 +1,5 @@
+import { GetParticipantStatusRequest } from "../../../core/types/requests/get-participant-status-request.js";
+import { GetParticipantStatusResponse } from "../../../core/types/responses/get-participant-status-response.js";
+import { ParticipantStatusResponse } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/participant_status_service.js";
+export declare function mapGrpcGetParticipantStatusRequest(_request: GetParticipantStatusRequest): Record<string, never>;
+export declare function mapGrpcParticipantStatusResponse(payload: Partial<ParticipantStatusResponse>): GetParticipantStatusResponse;

package/dist/transports/grpc/mappers/participant-status-mapper.js

@@ -0,0 +1,54 @@
+import { GetParticipantStatusResponse } from "../../../core/types/responses/get-participant-status-response.js";
+import { ConnectedSynchronizerHealth } from "../../../core/types/connected-synchronizer-health.js";
+import { ConnectedSynchronizerStatus } from "../../../core/types/connected-synchronizer-status.js";
+import { ParticipantNodeStatus } from "../../../core/types/participant-node-status.js";
+import { ConnectedSynchronizer_Health, } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/participant_status_service.js";
+import { mapGrpcAdminNodeStatus, mapGrpcAdminNotInitializedStatus, } from "./admin-status-mapper.js";
+export function mapGrpcGetParticipantStatusRequest(_request) {
+    return {};
+}
+export function mapGrpcParticipantStatusResponse(payload) {
+    switch (payload.kind?.oneofKind) {
+        case "status":
+            return new GetParticipantStatusResponse({
+                status: mapGrpcParticipantNodeStatus(payload.kind.status),
+            });
+        case "notInitialized":
+            return new GetParticipantStatusResponse({
+                notInitialized: mapGrpcAdminNotInitializedStatus(payload.kind.notInitialized),
+            });
+        default:
+            return new GetParticipantStatusResponse({});
+    }
+}
+function mapGrpcParticipantNodeStatus(payload) {
+    const commonStatus = mapGrpcAdminNodeStatus(payload.commonStatus);
+    return new ParticipantNodeStatus({
+        uid: commonStatus.uid,
+        uptime: commonStatus.uptime,
+        ports: { ...commonStatus.ports },
+        active: payload.active ?? commonStatus.active,
+        topologyQueues: commonStatus.topologyQueues,
+        components: [...commonStatus.components],
+        version: commonStatus.version,
+        connectedSynchronizers: (payload.connectedSynchronizers ?? []).map((item) => mapGrpcConnectedSynchronizerStatus(item)),
+        supportedProtocolVersions: [...(payload.supportedProtocolVersions ?? [])],
+    });
+}
+function mapGrpcConnectedSynchronizerStatus(payload) {
+    return new ConnectedSynchronizerStatus({
+        physicalSynchronizerId: payload.physicalSynchronizerId ?? "",
+        health: mapGrpcConnectedSynchronizerHealth(payload.health),
+    });
+}
+function mapGrpcConnectedSynchronizerHealth(value) {
+    switch (value) {
+        case ConnectedSynchronizer_Health.HEALTHY:
+            return ConnectedSynchronizerHealth.healthy;
+        case ConnectedSynchronizer_Health.UNHEALTHY:
+            return ConnectedSynchronizerHealth.unhealthy;
+        case ConnectedSynchronizer_Health.UNSPECIFIED:
+        default:
+            return ConnectedSynchronizerHealth.unspecified;
+    }
+}

package/dist/transports/grpc/mappers/parties-mapper.d.ts

@@ -0,0 +1,25 @@
+import { GetParticipantIdRequest } from "../../../core/types/requests/get-participant-id-request.js";
+import { GetPartiesRequest } from "../../../core/types/requests/get-parties-request.js";
+import { CreatePartyRequest } from "../../../core/types/requests/create-party-request.js";
+import { ListPartiesRequest } from "../../../core/types/requests/list-parties-request.js";
+import { CreatePartyResponse } from "../../../core/types/responses/create-party-response.js";
+import { GetParticipantIdResponse as SdkGetParticipantIdResponse } from "../../../core/types/responses/get-participant-id-response.js";
+import { GetPartiesResponse as SdkGetPartiesResponse } from "../../../core/types/responses/get-parties-response.js";
+import { ListPartiesResponse } from "../../../core/types/responses/list-parties-response.js";
+import { AllocatePartyRequest, AllocatePartyResponse, GetParticipantIdResponse, GetPartiesResponse, ListKnownPartiesRequest, ListKnownPartiesResponse } from "../generated/canton/com/daml/ledger/api/v2/admin/party_management_service.js";
+export declare function mapGrpcCreatePartyRequest(request: CreatePartyRequest): AllocatePartyRequest;
+export declare function mapGrpcCreateParty(payload: {
+    identifier?: string;
+    partyDetails?: {
+        party: string;
+    };
+} | AllocatePartyResponse): CreatePartyResponse;
+export declare function mapGrpcListPartiesRequest(request: ListPartiesRequest): ListKnownPartiesRequest;
+export declare function mapGrpcListParties(payload: ListKnownPartiesResponse): ListPartiesResponse;
+export declare function mapGrpcGetParticipantIdRequest(_request: GetParticipantIdRequest): Record<string, never>;
+export declare function mapGrpcGetParticipantId(payload: Partial<GetParticipantIdResponse>): SdkGetParticipantIdResponse;
+export declare function mapGrpcGetPartiesRequest(request: GetPartiesRequest): {
+    parties: string[];
+    identityProviderId: string;
+};
+export declare function mapGrpcGetParties(payload: Partial<GetPartiesResponse>): SdkGetPartiesResponse;

package/dist/transports/grpc/mappers/parties-mapper.js

@@ -0,0 +1,63 @@
+import { PartyDetails as SdkPartyDetails } from "../../../core/types/party-details.js";
+import { CreatePartyResponse } from "../../../core/types/responses/create-party-response.js";
+import { GetParticipantIdResponse as SdkGetParticipantIdResponse } from "../../../core/types/responses/get-participant-id-response.js";
+import { GetPartiesResponse as SdkGetPartiesResponse } from "../../../core/types/responses/get-parties-response.js";
+import { ListPartiesResponse } from "../../../core/types/responses/list-parties-response.js";
+export function mapGrpcCreatePartyRequest(request) {
+    return {
+        partyIdHint: request.partyIdHint ?? "",
+        identityProviderId: "",
+        synchronizerId: "",
+        userId: "",
+    };
+}
+export function mapGrpcCreateParty(payload) {
+    return new CreatePartyResponse({
+        party: payload.partyDetails?.party
+            ?? ("identifier" in payload ? payload.identifier : undefined)
+            ?? "",
+    });
+}
+export function mapGrpcListPartiesRequest(request) {
+    return {
+        identityProviderId: request.identityProviderId ?? "",
+        pageToken: request.pageToken ?? "",
+        pageSize: request.pageSize ?? 0,
+        filterParty: request.filterParty ?? "",
+    };
+}
+export function mapGrpcListParties(payload) {
+    return new ListPartiesResponse({
+        partyDetails: payload.partyDetails.map(item => new SdkPartyDetails({
+            party: item.party,
+            isLocal: item.isLocal,
+            localMetadata: item.localMetadata?.annotations,
+            identityProviderId: item.identityProviderId || undefined,
+        })),
+        nextPageToken: payload.nextPageToken || undefined,
+    });
+}
+export function mapGrpcGetParticipantIdRequest(_request) {
+    return {};
+}
+export function mapGrpcGetParticipantId(payload) {
+    return new SdkGetParticipantIdResponse({
+        participantId: payload.participantId ?? "",
+    });
+}
+export function mapGrpcGetPartiesRequest(request) {
+    return {
+        parties: [...request.parties],
+        identityProviderId: request.identityProviderId ?? "",
+    };
+}
+export function mapGrpcGetParties(payload) {
+    return new SdkGetPartiesResponse({
+        partyDetails: (payload.partyDetails ?? []).map(item => new SdkPartyDetails({
+            party: item.party,
+            isLocal: item.isLocal,
+            localMetadata: item.localMetadata?.annotations,
+            identityProviderId: item.identityProviderId || undefined,
+        })),
+    });
+}

package/dist/transports/grpc/mappers/pruning-mapper.d.ts

@@ -0,0 +1,18 @@
+import { GetNoWaitCommitmentsFromRequest } from "../../../core/types/requests/get-no-wait-commitments-from-request.js";
+import { GetParticipantPruningScheduleRequest } from "../../../core/types/requests/get-participant-pruning-schedule-request.js";
+import { GetPruningScheduleRequest } from "../../../core/types/requests/get-pruning-schedule-request.js";
+import { GetSafePruningOffsetRequest } from "../../../core/types/requests/get-safe-pruning-offset-request.js";
+import { GetNoWaitCommitmentsFromResponse } from "../../../core/types/responses/get-no-wait-commitments-from-response.js";
+import { GetParticipantPruningScheduleResponse } from "../../../core/types/responses/get-participant-pruning-schedule-response.js";
+import { GetPruningScheduleResponse } from "../../../core/types/responses/get-pruning-schedule-response.js";
+import { GetSafePruningOffsetResponse } from "../../../core/types/responses/get-safe-pruning-offset-response.js";
+import { GetSafePruningOffsetRequest as GrpcGetSafePruningOffsetRequest, GetSafePruningOffsetResponse as GrpcGetSafePruningOffsetResponse } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/pruning_service.js";
+import { GetNoWaitCommitmentsFromRequest as GrpcGetNoWaitCommitmentsFromRequest, GetNoWaitCommitmentsFromResponse as GrpcGetNoWaitCommitmentsFromResponse, GetParticipantScheduleRequest as GrpcGetParticipantScheduleRequest, GetParticipantScheduleResponse as GrpcGetParticipantScheduleResponse, GetScheduleRequest as GrpcGetScheduleRequest, GetScheduleResponse as GrpcGetScheduleResponse } from "../generated/canton/com/digitalasset/canton/admin/pruning/v30/pruning.js";
+export declare function mapGrpcGetSafePruningOffsetRequest(request: GetSafePruningOffsetRequest): GrpcGetSafePruningOffsetRequest;
+export declare function mapGrpcGetSafePruningOffset(payload?: Partial<GrpcGetSafePruningOffsetResponse>): GetSafePruningOffsetResponse;
+export declare function mapGrpcGetPruningScheduleRequest(_request: GetPruningScheduleRequest): GrpcGetScheduleRequest;
+export declare function mapGrpcGetPruningSchedule(payload?: Partial<GrpcGetScheduleResponse>): GetPruningScheduleResponse;
+export declare function mapGrpcGetParticipantPruningScheduleRequest(_request: GetParticipantPruningScheduleRequest): GrpcGetParticipantScheduleRequest;
+export declare function mapGrpcGetParticipantPruningSchedule(payload?: Partial<GrpcGetParticipantScheduleResponse>): GetParticipantPruningScheduleResponse;
+export declare function mapGrpcGetNoWaitCommitmentsFromRequest(request: GetNoWaitCommitmentsFromRequest): GrpcGetNoWaitCommitmentsFromRequest;
+export declare function mapGrpcGetNoWaitCommitmentsFrom(payload?: Partial<GrpcGetNoWaitCommitmentsFromResponse>): GetNoWaitCommitmentsFromResponse;

package/dist/transports/grpc/mappers/pruning-mapper.js

@@ -0,0 +1,92 @@
+import { ParticipantPruningSchedule } from "../../../core/types/participant-pruning-schedule.js";
+import { PruningSchedule } from "../../../core/types/pruning-schedule.js";
+import { SafeToPruneCommitmentState } from "../../../core/types/safe-to-prune-commitment-state.js";
+import { WaitCommitmentsSetup } from "../../../core/types/wait-commitments-setup.js";
+import { GetNoWaitCommitmentsFromResponse } from "../../../core/types/responses/get-no-wait-commitments-from-response.js";
+import { GetParticipantPruningScheduleResponse } from "../../../core/types/responses/get-participant-pruning-schedule-response.js";
+import { GetPruningScheduleResponse } from "../../../core/types/responses/get-pruning-schedule-response.js";
+import { GetSafePruningOffsetResponse } from "../../../core/types/responses/get-safe-pruning-offset-response.js";
+import { SafeToPruneCommitmentState as GrpcSafeToPruneCommitmentState, } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/pruning_service.js";
+import { mapGrpcTimestamp, mapSdkDuration } from "./topology-common-mapper.js";
+export function mapGrpcGetSafePruningOffsetRequest(request) {
+    return {
+        beforeOrAt: mapGrpcTimestamp(request.beforeOrAt),
+        ledgerEnd: request.ledgerEnd,
+        counterParticipantsCommitmentsState: mapGrpcSafeToPruneCommitmentState(request.counterParticipantsCommitmentsState),
+    };
+}
+export function mapGrpcGetSafePruningOffset(payload) {
+    return new GetSafePruningOffsetResponse({
+        hasSafePruningOffset: payload?.response?.oneofKind === "safePruningOffset",
+        safePruningOffset: payload?.response?.oneofKind === "safePruningOffset"
+            ? payload.response.safePruningOffset
+            : undefined,
+    });
+}
+export function mapGrpcGetPruningScheduleRequest(_request) {
+    return {};
+}
+export function mapGrpcGetPruningSchedule(payload) {
+    return new GetPruningScheduleResponse({
+        schedule: mapGrpcPruningSchedule(payload?.schedule),
+    });
+}
+export function mapGrpcGetParticipantPruningScheduleRequest(_request) {
+    return {};
+}
+export function mapGrpcGetParticipantPruningSchedule(payload) {
+    return new GetParticipantPruningScheduleResponse({
+        schedule: mapGrpcParticipantPruningSchedule(payload?.schedule),
+    });
+}
+export function mapGrpcGetNoWaitCommitmentsFromRequest(request) {
+    return {
+        synchronizerIds: [...request.synchronizerIds],
+        participantUids: [...request.participantUids],
+    };
+}
+export function mapGrpcGetNoWaitCommitmentsFrom(payload) {
+    return new GetNoWaitCommitmentsFromResponse({
+        ignoredParticipants: (payload?.ignoredParticipants ?? []).map((item) => mapGrpcWaitCommitmentsSetup(item)),
+        notIgnoredParticipants: (payload?.notIgnoredParticipants ?? []).map((item) => mapGrpcWaitCommitmentsSetup(item)),
+    });
+}
+function mapGrpcSafeToPruneCommitmentState(value) {
+    switch (value) {
+        case SafeToPruneCommitmentState.match:
+            return GrpcSafeToPruneCommitmentState.MATCH;
+        case SafeToPruneCommitmentState.matchMismatch:
+            return GrpcSafeToPruneCommitmentState.MATCH_MISMATCH;
+        case SafeToPruneCommitmentState.all:
+            return GrpcSafeToPruneCommitmentState.ALL;
+        case SafeToPruneCommitmentState.unspecified:
+            return GrpcSafeToPruneCommitmentState.UNSPECIFIED;
+        default:
+            return undefined;
+    }
+}
+function mapGrpcPruningSchedule(payload) {
+    if (payload === undefined) {
+        return undefined;
+    }
+    return new PruningSchedule({
+        cron: payload.cron,
+        maxDuration: mapSdkDuration(payload.maxDuration),
+        retention: mapSdkDuration(payload.retention),
+    });
+}
+function mapGrpcParticipantPruningSchedule(payload) {
+    if (payload === undefined) {
+        return undefined;
+    }
+    return new ParticipantPruningSchedule({
+        schedule: mapGrpcPruningSchedule(payload.schedule),
+        pruneInternallyOnly: payload.pruneInternallyOnly,
+    });
+}
+function mapGrpcWaitCommitmentsSetup(payload) {
+    return new WaitCommitmentsSetup({
+        counterParticipantUid: payload?.counterParticipantUid ?? "",
+        synchronizerIds: [...(payload?.synchronizers?.synchronizerIds ?? [])],
+    });
+}

package/dist/transports/grpc/mappers/resource-management-mapper.d.ts

@@ -0,0 +1,5 @@
+import { GetResourceLimitsRequest } from "../../../core/types/requests/get-resource-limits-request.js";
+import { GetResourceLimitsResponse } from "../../../core/types/responses/get-resource-limits-response.js";
+import { GetResourceLimitsResponse as GrpcGetResourceLimitsResponse } from "../generated/canton/com/digitalasset/canton/admin/participant/v30/resource_management_service.js";
+export declare function mapGrpcGetResourceLimitsRequest(_request: GetResourceLimitsRequest): Record<string, never>;
+export declare function mapGrpcGetResourceLimits(payload: Partial<GrpcGetResourceLimitsResponse>): GetResourceLimitsResponse;

package/dist/transports/grpc/mappers/resource-management-mapper.js

@@ -0,0 +1,16 @@
+import { ResourceLimits } from "../../../core/types/resource-limits.js";
+import { GetResourceLimitsResponse } from "../../../core/types/responses/get-resource-limits-response.js";
+export function mapGrpcGetResourceLimitsRequest(_request) {
+    return {};
+}
+export function mapGrpcGetResourceLimits(payload) {
+    return new GetResourceLimitsResponse({
+        currentLimits: payload.currentLimits === undefined
+            ? undefined
+            : new ResourceLimits({
+                maxInflightValidationRequests: payload.currentLimits.maxInflightValidationRequests,
+                maxSubmissionRate: payload.currentLimits.maxSubmissionRate,
+                maxSubmissionBurstFactor: payload.currentLimits.maxSubmissionBurstFactor,
+            }),
+    });
+}

package/dist/transports/grpc/mappers/state-read-mapper.d.ts

@@ -0,0 +1,23 @@
+import { SynchronizerTime } from "../../../core/types/synchronizer-time.js";
+import { GetConnectedSynchronizersRequest } from "../../../core/types/requests/get-connected-synchronizers-request.js";
+import { GetLedgerEndRequest } from "../../../core/types/requests/get-ledger-end-request.js";
+import { GetLatestPrunedOffsetsRequest } from "../../../core/types/requests/get-latest-pruned-offsets-request.js";
+import { GetConnectedSynchronizersResponse } from "../../../core/types/responses/get-connected-synchronizers-response.js";
+import { GetLedgerEndResponse } from "../../../core/types/responses/get-ledger-end-response.js";
+import { GetLatestPrunedOffsetsResponse } from "../../../core/types/responses/get-latest-pruned-offsets-response.js";
+import { GetConnectedSynchronizersResponse as GrpcGetConnectedSynchronizersResponse, GetLedgerEndResponse as GrpcGetLedgerEndResponse, GetLatestPrunedOffsetsResponse as GrpcGetLatestPrunedOffsetsResponse } from "../generated/canton/com/daml/ledger/api/v2/state_service.js";
+import { Timestamp } from "../generated/canton/google/protobuf/timestamp.js";
+export declare function mapGrpcGetConnectedSynchronizersRequest(request: GetConnectedSynchronizersRequest): {
+    party: string;
+    participantId: string;
+    identityProviderId: string;
+};
+export declare function mapGrpcGetConnectedSynchronizers(payload: Partial<GrpcGetConnectedSynchronizersResponse>): GetConnectedSynchronizersResponse;
+export declare function mapGrpcGetLedgerEndRequest(_request: GetLedgerEndRequest): Record<string, never>;
+export declare function mapGrpcGetLedgerEnd(payload: Partial<GrpcGetLedgerEndResponse>): GetLedgerEndResponse;
+export declare function mapGrpcGetLatestPrunedOffsetsRequest(_request: GetLatestPrunedOffsetsRequest): Record<string, never>;
+export declare function mapGrpcGetLatestPrunedOffsets(payload: Partial<GrpcGetLatestPrunedOffsetsResponse>): GetLatestPrunedOffsetsResponse;
+export declare function mapGrpcSynchronizerTime(payload: {
+    synchronizerId?: string;
+    recordTime?: Timestamp;
+}): SynchronizerTime;