@distrohelena/canton-typescript-sdk 0.1.0

package/dist/core/types/responses/list-sequencing-parameters-state-response.d.ts

@@ -0,0 +1,8 @@
+import { DynamicSequencingParameters } from "../topology/dynamic-sequencing-parameters.js";
+import { TopologyMappingResult } from "../topology/topology-mapping-result.js";
+export declare class ListSequencingParametersStateResponse {
+    readonly results: TopologyMappingResult<DynamicSequencingParameters>[];
+    constructor(init: {
+        results: TopologyMappingResult<DynamicSequencingParameters>[];
+    });
+}

package/dist/core/types/responses/list-sequencing-parameters-state-response.js

@@ -0,0 +1,6 @@
+export class ListSequencingParametersStateResponse {
+    results;
+    constructor(init) {
+        this.results = [...init.results];
+    }
+}

package/dist/core/types/responses/list-synchronizer-parameters-state-response.d.ts

@@ -0,0 +1,8 @@
+import { DynamicSynchronizerParameters } from "../topology/dynamic-synchronizer-parameters.js";
+import { TopologyMappingResult } from "../topology/topology-mapping-result.js";
+export declare class ListSynchronizerParametersStateResponse {
+    readonly results: TopologyMappingResult<DynamicSynchronizerParameters>[];
+    constructor(init: {
+        results: TopologyMappingResult<DynamicSynchronizerParameters>[];
+    });
+}

package/dist/core/types/responses/list-synchronizer-parameters-state-response.js

@@ -0,0 +1,6 @@
+export class ListSynchronizerParametersStateResponse {
+    results;
+    constructor(init) {
+        this.results = [...init.results];
+    }
+}

package/dist/core/types/responses/list-synchronizer-trust-certificate-response.d.ts

@@ -0,0 +1,8 @@
+import { SynchronizerTrustCertificate } from "../topology/synchronizer-trust-certificate.js";
+import { TopologyMappingResult } from "../topology/topology-mapping-result.js";
+export declare class ListSynchronizerTrustCertificateResponse {
+    readonly results: TopologyMappingResult<SynchronizerTrustCertificate>[];
+    constructor(init: {
+        results: TopologyMappingResult<SynchronizerTrustCertificate>[];
+    });
+}

package/dist/core/types/responses/list-synchronizer-trust-certificate-response.js

@@ -0,0 +1,6 @@
+export class ListSynchronizerTrustCertificateResponse {
+    results;
+    constructor(init) {
+        this.results = [...init.results];
+    }
+}

package/dist/core/types/responses/list-user-rights-response.d.ts

@@ -0,0 +1,7 @@
+import { UserRightAssignment } from "../requests/grant-user-rights-request.js";
+export declare class ListUserRightsResponse {
+    readonly rights: readonly UserRightAssignment[];
+    constructor(init: {
+        rights: readonly UserRightAssignment[];
+    });
+}

package/dist/core/types/responses/list-user-rights-response.js

@@ -0,0 +1,6 @@
+export class ListUserRightsResponse {
+    rights;
+    constructor(init) {
+        this.rights = init.rights;
+    }
+}

package/dist/core/types/responses/list-users-response.d.ts

@@ -0,0 +1,9 @@
+import { LedgerUser } from "../ledger-user.js";
+export declare class ListUsersResponse {
+    readonly users: readonly LedgerUser[];
+    readonly nextPageToken?: string;
+    constructor(init: {
+        users: readonly LedgerUser[];
+        nextPageToken?: string;
+    });
+}

package/dist/core/types/responses/list-users-response.js

@@ -0,0 +1,8 @@
+export class ListUsersResponse {
+    users;
+    nextPageToken;
+    constructor(init) {
+        this.users = init.users;
+        this.nextPageToken = init.nextPageToken;
+    }
+}

package/dist/core/types/responses/list-vetted-packages-response.d.ts

@@ -0,0 +1,9 @@
+import { VettedPackages } from "../vetted-packages.js";
+export declare class ListVettedPackagesResponse {
+    readonly vettedPackages: VettedPackages[];
+    readonly nextPageToken?: string;
+    constructor(init: {
+        vettedPackages: VettedPackages[];
+        nextPageToken?: string;
+    });
+}

package/dist/core/types/responses/list-vetted-packages-response.js

@@ -0,0 +1,8 @@
+export class ListVettedPackagesResponse {
+    vettedPackages;
+    nextPageToken;
+    constructor(init) {
+        this.vettedPackages = [...init.vettedPackages];
+        this.nextPageToken = init.nextPageToken;
+    }
+}

package/dist/core/types/responses/lookup-offset-by-time-response.d.ts

@@ -0,0 +1,6 @@
+export declare class LookupOffsetByTimeResponse {
+    readonly offset?: string;
+    constructor(init?: {
+        offset?: string;
+    });
+}

package/dist/core/types/responses/lookup-offset-by-time-response.js

@@ -0,0 +1,6 @@
+export class LookupOffsetByTimeResponse {
+    offset;
+    constructor(init) {
+        this.offset = init?.offset;
+    }
+}

package/dist/core/types/responses/lookup-received-acs-commitments-response.d.ts

@@ -0,0 +1,7 @@
+import { ReceivedAcsCommitmentPerSynchronizer } from "../received-acs-commitment-per-synchronizer.js";
+export declare class LookupReceivedAcsCommitmentsResponse {
+    readonly received: readonly ReceivedAcsCommitmentPerSynchronizer[];
+    constructor(init: {
+        received: readonly ReceivedAcsCommitmentPerSynchronizer[];
+    });
+}

package/dist/core/types/responses/lookup-received-acs-commitments-response.js

@@ -0,0 +1,6 @@
+export class LookupReceivedAcsCommitmentsResponse {
+    received;
+    constructor(init) {
+        this.received = [...init.received];
+    }
+}

package/dist/core/types/responses/lookup-sent-acs-commitments-response.d.ts

@@ -0,0 +1,7 @@
+import { SentAcsCommitmentPerSynchronizer } from "../sent-acs-commitment-per-synchronizer.js";
+export declare class LookupSentAcsCommitmentsResponse {
+    readonly sent: readonly SentAcsCommitmentPerSynchronizer[];
+    constructor(init: {
+        sent: readonly SentAcsCommitmentPerSynchronizer[];
+    });
+}

package/dist/core/types/responses/lookup-sent-acs-commitments-response.js

@@ -0,0 +1,6 @@
+export class LookupSentAcsCommitmentsResponse {
+    sent;
+    constructor(init) {
+        this.sent = [...init.sent];
+    }
+}

package/dist/core/types/responses/open-commitment-response.d.ts

@@ -0,0 +1,6 @@
+export declare class OpenCommitmentResponse {
+    readonly chunk: Uint8Array;
+    constructor(init?: {
+        chunk?: Uint8Array;
+    });
+}

package/dist/core/types/responses/open-commitment-response.js

@@ -0,0 +1,6 @@
+export class OpenCommitmentResponse {
+    chunk;
+    constructor(init = {}) {
+        this.chunk = new Uint8Array(init.chunk ?? []);
+    }
+}

package/dist/core/types/responses/participant-list-packages-response.d.ts

@@ -0,0 +1,7 @@
+import { ParticipantPackageDescription } from "../participant-package-description.js";
+export declare class ParticipantListPackagesResponse {
+    readonly packageDescriptions: ParticipantPackageDescription[];
+    constructor(init: {
+        packageDescriptions: ParticipantPackageDescription[];
+    });
+}

package/dist/core/types/responses/participant-list-packages-response.js

@@ -0,0 +1,6 @@
+export class ParticipantListPackagesResponse {
+    packageDescriptions;
+    constructor(init) {
+        this.packageDescriptions = [...init.packageDescriptions];
+    }
+}

package/dist/core/types/responses/query-contracts-response.d.ts

@@ -0,0 +1,6 @@
+export declare class QueryContractsResponse<TContract = unknown> {
+    readonly contracts: readonly TContract[];
+    constructor(init: {
+        contracts: readonly TContract[];
+    });
+}

package/dist/core/types/responses/query-contracts-response.js

@@ -0,0 +1,6 @@
+export class QueryContractsResponse {
+    contracts;
+    constructor(init) {
+        this.contracts = init.contracts;
+    }
+}

package/dist/core/types/responses/submit-command-response.d.ts

@@ -0,0 +1,8 @@
+export declare class SubmitCommandResponse {
+    readonly commandId?: string;
+    readonly transactionId?: string;
+    constructor(init?: {
+        commandId?: string;
+        transactionId?: string;
+    });
+}

package/dist/core/types/responses/submit-command-response.js

@@ -0,0 +1,8 @@
+export class SubmitCommandResponse {
+    commandId;
+    transactionId;
+    constructor(init = {}) {
+        this.commandId = init.commandId;
+        this.transactionId = init.transactionId;
+    }
+}

package/dist/core/types/responses/topology-list-parties-response.d.ts

@@ -0,0 +1,7 @@
+import { TopologyPartyResult } from "../topology/topology-party-result.js";
+export declare class TopologyListPartiesResponse {
+    readonly results: TopologyPartyResult[];
+    constructor(init: {
+        results: TopologyPartyResult[];
+    });
+}

package/dist/core/types/responses/topology-list-parties-response.js

@@ -0,0 +1,6 @@
+export class TopologyListPartiesResponse {
+    results;
+    constructor(init) {
+        this.results = [...init.results];
+    }
+}

package/dist/core/types/responses/topology-list-vetted-packages-response.d.ts

@@ -0,0 +1,8 @@
+import { TopologyMappingResult } from "../topology/topology-mapping-result.js";
+import { TopologyVettedPackages } from "../topology/vetted-packages.js";
+export declare class TopologyListVettedPackagesResponse {
+    readonly results: TopologyMappingResult<TopologyVettedPackages>[];
+    constructor(init: {
+        results: TopologyMappingResult<TopologyVettedPackages>[];
+    });
+}

package/dist/core/types/responses/topology-list-vetted-packages-response.js

@@ -0,0 +1,6 @@
+export class TopologyListVettedPackagesResponse {
+    results;
+    constructor(init) {
+        this.results = [...init.results];
+    }
+}

package/dist/core/types/responses/traffic-control-state-response.d.ts

@@ -0,0 +1,7 @@
+import { TrafficState } from "../traffic-state.js";
+export declare class TrafficControlStateResponse {
+    readonly trafficState?: TrafficState;
+    constructor(init?: {
+        trafficState?: TrafficState;
+    });
+}

package/dist/core/types/responses/traffic-control-state-response.js

@@ -0,0 +1,6 @@
+export class TrafficControlStateResponse {
+    trafficState;
+    constructor(init) {
+        this.trafficState = init?.trafficState;
+    }
+}

package/dist/core/types/responses/upload-dar-file-response.d.ts

@@ -0,0 +1,6 @@
+export declare class UploadDarFileResponse {
+    readonly packageId?: string;
+    constructor(init?: {
+        packageId?: string;
+    });
+}

package/dist/core/types/responses/upload-dar-file-response.js

@@ -0,0 +1,6 @@
+export class UploadDarFileResponse {
+    packageId;
+    constructor(init = {}) {
+        this.packageId = init.packageId;
+    }
+}

package/dist/core/types/responses/upload-package-response.d.ts

@@ -0,0 +1,6 @@
+export declare class UploadPackageResponse {
+    readonly packageId?: string;
+    constructor(init?: {
+        packageId?: string;
+    });
+}

package/dist/core/types/responses/upload-package-response.js

@@ -0,0 +1,6 @@
+export class UploadPackageResponse {
+    packageId;
+    constructor(init = {}) {
+        this.packageId = init.packageId;
+    }
+}

package/dist/core/types/safe-to-prune-commitment-state.d.ts

@@ -0,0 +1,6 @@
+export declare enum SafeToPruneCommitmentState {
+    unspecified = 0,
+    match = 1,
+    matchMismatch = 2,
+    all = 3
+}

package/dist/core/types/safe-to-prune-commitment-state.js

@@ -0,0 +1,7 @@
+export var SafeToPruneCommitmentState;
+(function (SafeToPruneCommitmentState) {
+    SafeToPruneCommitmentState[SafeToPruneCommitmentState["unspecified"] = 0] = "unspecified";
+    SafeToPruneCommitmentState[SafeToPruneCommitmentState["match"] = 1] = "match";
+    SafeToPruneCommitmentState[SafeToPruneCommitmentState["matchMismatch"] = 2] = "matchMismatch";
+    SafeToPruneCommitmentState[SafeToPruneCommitmentState["all"] = 3] = "all";
+})(SafeToPruneCommitmentState || (SafeToPruneCommitmentState = {}));

package/dist/core/types/sdk-command.d.ts

@@ -0,0 +1,18 @@
+export declare class SdkCommand {
+    readonly type: string;
+    readonly templateId?: string;
+    readonly contractId?: string;
+    readonly contractKey?: unknown;
+    readonly choice?: string;
+    readonly createArguments?: Record<string, unknown>;
+    readonly choiceArgument?: unknown;
+    constructor(init: {
+        type: string;
+        templateId?: string;
+        contractId?: string;
+        contractKey?: unknown;
+        choice?: string;
+        createArguments?: Record<string, unknown>;
+        choiceArgument?: unknown;
+    });
+}

package/dist/core/types/sdk-command.js

@@ -0,0 +1,18 @@
+export class SdkCommand {
+    type;
+    templateId;
+    contractId;
+    contractKey;
+    choice;
+    createArguments;
+    choiceArgument;
+    constructor(init) {
+        this.type = init.type;
+        this.templateId = init.templateId;
+        this.contractId = init.contractId;
+        this.contractKey = init.contractKey;
+        this.choice = init.choice;
+        this.createArguments = init.createArguments;
+        this.choiceArgument = init.choiceArgument;
+    }
+}

package/dist/core/types/sent-acs-commitment-per-synchronizer.d.ts

@@ -0,0 +1,9 @@
+import { SentAcsCommitment } from "./sent-acs-commitment.js";
+export declare class SentAcsCommitmentPerSynchronizer {
+    readonly synchronizerId: string;
+    readonly sent: readonly SentAcsCommitment[];
+    constructor(init: {
+        synchronizerId: string;
+        sent: readonly SentAcsCommitment[];
+    });
+}

package/dist/core/types/sent-acs-commitment-per-synchronizer.js

@@ -0,0 +1,8 @@
+export class SentAcsCommitmentPerSynchronizer {
+    synchronizerId;
+    sent;
+    constructor(init) {
+        this.synchronizerId = init.synchronizerId;
+        this.sent = [...init.sent];
+    }
+}

package/dist/core/types/sent-acs-commitment-state.d.ts

@@ -0,0 +1,6 @@
+export declare enum SentAcsCommitmentState {
+    unspecified = "unspecified",
+    match = "match",
+    mismatch = "mismatch",
+    notCompared = "notCompared"
+}

package/dist/core/types/sent-acs-commitment-state.js

@@ -0,0 +1,7 @@
+export var SentAcsCommitmentState;
+(function (SentAcsCommitmentState) {
+    SentAcsCommitmentState["unspecified"] = "unspecified";
+    SentAcsCommitmentState["match"] = "match";
+    SentAcsCommitmentState["mismatch"] = "mismatch";
+    SentAcsCommitmentState["notCompared"] = "notCompared";
+})(SentAcsCommitmentState || (SentAcsCommitmentState = {}));

package/dist/core/types/sent-acs-commitment.d.ts

@@ -0,0 +1,16 @@
+import { CommitmentInterval } from "./commitment-interval.js";
+import { SentAcsCommitmentState } from "./sent-acs-commitment-state.js";
+export declare class SentAcsCommitment {
+    readonly interval?: CommitmentInterval;
+    readonly destCounterParticipantUid: string;
+    readonly ownCommitment?: Uint8Array;
+    readonly receivedCommitment?: Uint8Array;
+    readonly state: SentAcsCommitmentState;
+    constructor(init: {
+        interval?: CommitmentInterval;
+        destCounterParticipantUid: string;
+        ownCommitment?: Uint8Array;
+        receivedCommitment?: Uint8Array;
+        state: SentAcsCommitmentState;
+    });
+}

package/dist/core/types/sent-acs-commitment.js

@@ -0,0 +1,20 @@
+export class SentAcsCommitment {
+    interval;
+    destCounterParticipantUid;
+    ownCommitment;
+    receivedCommitment;
+    state;
+    constructor(init) {
+        this.interval = init.interval;
+        this.destCounterParticipantUid = init.destCounterParticipantUid;
+        this.ownCommitment =
+            init.ownCommitment === undefined
+                ? undefined
+                : new Uint8Array(init.ownCommitment);
+        this.receivedCommitment =
+            init.receivedCommitment === undefined
+                ? undefined
+                : new Uint8Array(init.receivedCommitment);
+        this.state = init.state;
+    }
+}

package/dist/core/types/slow-counter-participant-synchronizer-config.d.ts

@@ -0,0 +1,14 @@
+export declare class SlowCounterParticipantSynchronizerConfig {
+    readonly synchronizerIds: readonly string[];
+    readonly distinguishedParticipantUids: readonly string[];
+    readonly thresholdDistinguished: string;
+    readonly thresholdDefault: string;
+    readonly participantUidsMetrics: readonly string[];
+    constructor(init: {
+        synchronizerIds: readonly string[];
+        distinguishedParticipantUids: readonly string[];
+        thresholdDistinguished?: string;
+        thresholdDefault?: string;
+        participantUidsMetrics: readonly string[];
+    });
+}

package/dist/core/types/slow-counter-participant-synchronizer-config.js

@@ -0,0 +1,16 @@
+export class SlowCounterParticipantSynchronizerConfig {
+    synchronizerIds;
+    distinguishedParticipantUids;
+    thresholdDistinguished;
+    thresholdDefault;
+    participantUidsMetrics;
+    constructor(init) {
+        this.synchronizerIds = [...init.synchronizerIds];
+        this.distinguishedParticipantUids = [
+            ...init.distinguishedParticipantUids,
+        ];
+        this.thresholdDistinguished = init.thresholdDistinguished ?? "";
+        this.thresholdDefault = init.thresholdDefault ?? "";
+        this.participantUidsMetrics = [...init.participantUidsMetrics];
+    }
+}

package/dist/core/types/submission-mode.d.ts

@@ -0,0 +1,4 @@
+export declare enum SubmissionMode {
+    synchronous = "synchronous",
+    asynchronous = "asynchronous"
+}

package/dist/core/types/submission-mode.js

@@ -0,0 +1,5 @@
+export var SubmissionMode;
+(function (SubmissionMode) {
+    SubmissionMode["synchronous"] = "synchronous";
+    SubmissionMode["asynchronous"] = "asynchronous";
+})(SubmissionMode || (SubmissionMode = {}));

package/dist/core/types/synchronizer-time-range.d.ts

@@ -0,0 +1,9 @@
+import { CommitmentTimeRange } from "./commitment-time-range.js";
+export declare class SynchronizerTimeRange {
+    readonly synchronizerId: string;
+    readonly interval?: CommitmentTimeRange;
+    constructor(init: {
+        synchronizerId: string;
+        interval?: CommitmentTimeRange;
+    });
+}

package/dist/core/types/synchronizer-time-range.js

@@ -0,0 +1,8 @@
+export class SynchronizerTimeRange {
+    synchronizerId;
+    interval;
+    constructor(init) {
+        this.synchronizerId = init.synchronizerId;
+        this.interval = init.interval;
+    }
+}

package/dist/core/types/synchronizer-time.d.ts

@@ -0,0 +1,8 @@
+export declare class SynchronizerTime {
+    readonly synchronizerId: string;
+    readonly recordTime?: Date;
+    constructor(init: {
+        synchronizerId: string;
+        recordTime?: Date;
+    });
+}

package/dist/core/types/synchronizer-time.js

@@ -0,0 +1,8 @@
+export class SynchronizerTime {
+    synchronizerId;
+    recordTime;
+    constructor(init) {
+        this.synchronizerId = init.synchronizerId;
+        this.recordTime = init.recordTime;
+    }
+}

package/dist/core/types/topology/decentralized-namespace-definition.d.ts

@@ -0,0 +1,10 @@
+export declare class DecentralizedNamespaceDefinition {
+    readonly decentralizedNamespace: string;
+    readonly threshold: number;
+    readonly owners: string[];
+    constructor(init: {
+        decentralizedNamespace: string;
+        threshold: number;
+        owners?: string[];
+    });
+}

package/dist/core/types/topology/decentralized-namespace-definition.js

@@ -0,0 +1,10 @@
+export class DecentralizedNamespaceDefinition {
+    decentralizedNamespace;
+    threshold;
+    owners;
+    constructor(init) {
+        this.decentralizedNamespace = init.decentralizedNamespace;
+        this.threshold = init.threshold;
+        this.owners = [...(init.owners ?? [])];
+    }
+}

package/dist/core/types/topology/dynamic-sequencing-parameters.d.ts

@@ -0,0 +1,6 @@
+export declare class DynamicSequencingParameters {
+    readonly payload: Uint8Array;
+    constructor(init?: {
+        payload?: Uint8Array;
+    });
+}

package/dist/core/types/topology/dynamic-sequencing-parameters.js

@@ -0,0 +1,6 @@
+export class DynamicSequencingParameters {
+    payload;
+    constructor(init = {}) {
+        this.payload = new Uint8Array(init.payload ?? []);
+    }
+}

package/dist/core/types/topology/dynamic-synchronizer-parameters.d.ts

@@ -0,0 +1,68 @@
+import { TopologyDuration } from "./topology-duration.js";
+export declare enum OnboardingRestriction {
+    unspecified = "unspecified",
+    unrestrictedOpen = "unrestrictedOpen",
+    unrestrictedLocked = "unrestrictedLocked",
+    restrictedOpen = "restrictedOpen",
+    restrictedLocked = "restrictedLocked"
+}
+export declare class TrafficControlParameters {
+    readonly maxBaseTrafficAmount: string;
+    readonly maxBaseTrafficAccumulationDuration?: TopologyDuration;
+    readonly readVsWriteScalingFactor: number;
+    readonly setBalanceRequestSubmissionWindowSize?: TopologyDuration;
+    readonly enforceRateLimiting: boolean;
+    readonly baseEventCost?: string;
+    readonly freeConfirmationResponses: boolean;
+    constructor(init?: {
+        maxBaseTrafficAmount?: string;
+        maxBaseTrafficAccumulationDuration?: TopologyDuration;
+        readVsWriteScalingFactor?: number;
+        setBalanceRequestSubmissionWindowSize?: TopologyDuration;
+        enforceRateLimiting?: boolean;
+        baseEventCost?: string;
+        freeConfirmationResponses?: boolean;
+    });
+}
+export declare class AcsCommitmentsCatchUpConfig {
+    readonly catchupIntervalSkip: number;
+    readonly nrIntervalsToTriggerCatchup: number;
+    constructor(init?: {
+        catchupIntervalSkip?: number;
+        nrIntervalsToTriggerCatchup?: number;
+    });
+}
+export declare class DynamicSynchronizerParameters {
+    readonly confirmationResponseTimeout?: TopologyDuration;
+    readonly mediatorReactionTimeout?: TopologyDuration;
+    readonly assignmentExclusivityTimeout?: TopologyDuration;
+    readonly ledgerTimeRecordTimeTolerance?: TopologyDuration;
+    readonly reconciliationInterval?: TopologyDuration;
+    readonly mediatorDeduplicationTimeout?: TopologyDuration;
+    readonly maxRequestSize: number;
+    readonly onboardingRestriction: OnboardingRestriction;
+    readonly participantSynchronizerLimits?: {
+        confirmationRequestsMaxRate: number;
+    };
+    readonly sequencerAggregateSubmissionTimeout?: TopologyDuration;
+    readonly trafficControl?: TrafficControlParameters;
+    readonly acsCommitmentsCatchup?: AcsCommitmentsCatchUpConfig;
+    readonly preparationTimeRecordTimeTolerance?: TopologyDuration;
+    constructor(init?: {
+        confirmationResponseTimeout?: TopologyDuration;
+        mediatorReactionTimeout?: TopologyDuration;
+        assignmentExclusivityTimeout?: TopologyDuration;
+        ledgerTimeRecordTimeTolerance?: TopologyDuration;
+        reconciliationInterval?: TopologyDuration;
+        mediatorDeduplicationTimeout?: TopologyDuration;
+        maxRequestSize?: number;
+        onboardingRestriction?: OnboardingRestriction;
+        participantSynchronizerLimits?: {
+            confirmationRequestsMaxRate: number;
+        };
+        sequencerAggregateSubmissionTimeout?: TopologyDuration;
+        trafficControl?: TrafficControlParameters;
+        acsCommitmentsCatchup?: AcsCommitmentsCatchUpConfig;
+        preparationTimeRecordTimeTolerance?: TopologyDuration;
+    });
+}