@fairmint/canton-node-sdk 0.0.90 → 0.0.92

package/build/src/generated/canton/community/ledger/ledger-json-api/src/test/resources/json-api-docs/openapi.d.ts

@@ -114,7 +114,12 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Query completions list (blocking call) */
+        /** @description Query completions list (blocking call)
+         *     Notice: This endpoint should be used for small results set.
+         *     When number of results exceeded node configuration limit (`http-list-max-elements-limit`)
+         *     there will be an error (`413 Content Too Large`) returned.
+         *     Increasing this limit may lead to performance issues and high memory consumption.
+         *     Consider using websockets (asyncapi) for better efficiency with larger results. */
         post: operations["postV2CommandsCompletions"];
         delete?: never;
         options?: never;
@@ -226,6 +231,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v2/parties/external/allocate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Allocate a new external party */
+        post: operations["postV2PartiesExternalAllocate"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v2/parties/participant-id": {
         parameters: {
             query?: never;
@@ -261,6 +283,23 @@ export interface paths {
         patch: operations["patchV2PartiesParty"];
         trace?: never;
     };
+    "/v2/parties/external/generate-topology": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Generate a topology for an external party */
+        post: operations["postV2PartiesExternalGenerate-topology"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v2/state/active-contracts": {
         parameters: {
             query?: never;
@@ -270,7 +309,17 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Query active contracts list (blocking call) */
+        /** @description Query active contracts list (blocking call).
+         *     Querying active contracts is an expensive operation and if possible should not be repeated often.
+         *     Consider querying active contracts initially (for a given offset)
+         *     and then repeatedly call one of `/v2/updates/...`endpoints  to get subsequent modifications.
+         *     You can also use websockets to get updates with better performance.
+         *
+         *     Notice: This endpoint should be used for small results set.
+         *     When number of results exceeded node configuration limit (`http-list-max-elements-limit`)
+         *     there will be an error (`413 Content Too Large`) returned.
+         *     Increasing this limit may lead to performance issues and high memory consumption.
+         *     Consider using websockets (asyncapi) for better efficiency with larger results. */
         post: operations["postV2StateActive-contracts"];
         delete?: never;
         options?: never;
@@ -329,6 +378,28 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v2/updates": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Query updates list (blocking call)
+         *     Notice: This endpoint should be used for small results set.
+         *     When number of results exceeded node configuration limit (`http-list-max-elements-limit`)
+         *     there will be an error (`413 Content Too Large`) returned.
+         *     Increasing this limit may lead to performance issues and high memory consumption.
+         *     Consider using websockets (asyncapi) for better efficiency with larger results. */
+        post: operations["postV2Updates"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v2/updates/flats": {
         parameters: {
             query?: never;
@@ -338,7 +409,12 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Query flat transactions update list (blocking call) */
+        /** @description Query flat transactions update list (blocking call)
+         *     Notice: This endpoint should be used for small results set.
+         *     When number of results exceeded node configuration limit (`http-list-max-elements-limit`)
+         *     there will be an error (`413 Content Too Large`) returned.
+         *     Increasing this limit may lead to performance issues and high memory consumption.
+         *     Consider using websockets (asyncapi) for better efficiency with larger results. */
         post: operations["postV2UpdatesFlats"];
         delete?: never;
         options?: never;
@@ -355,7 +431,12 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Query update transactions tree list (blocking call) */
+        /** @description Query update transactions tree list (blocking call)
+         *     Notice: This endpoint should be used for small results set.
+         *     When number of results exceeded node configuration limit (`http-list-max-elements-limit`)
+         *     there will be an error (`413 Content Too Large`) returned.
+         *     Increasing this limit may lead to performance issues and high memory consumption.
+         *     Consider using websockets (asyncapi) for better efficiency with larger results. */
         post: operations["postV2UpdatesTrees"];
         delete?: never;
         options?: never;
@@ -647,6 +728,39 @@ export interface paths {
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
+        /**
+         * AllocateExternalPartyRequest
+         * @description Required authorization: ``HasRight(ParticipantAdmin) OR IsAuthenticatedIdentityProviderAdmin(identity_provider_id)``
+         */
+        AllocateExternalPartyRequest: {
+            /** @description TODO(#27670) support synchronizer aliases
+             *     Synchronizer ID on which to onboard the party
+             *     Required */
+            synchronizer: string;
+            /** @description TopologyTransactions to onboard the external party
+             *     Can contain:
+             *     - A namespace for the party.
+             *     This can be either a single NamespaceDelegation,
+             *     or DecentralizedNamespaceDefinition along with its authorized namespace owners in the form of NamespaceDelegations.
+             *     May be provided, if so it must be fully authorized by the signatures in this request combined with the existing topology state.
+             *     - A PartyToKeyMapping to register the party's signing keys.
+             *     May be provided, if so it must be fully authorized by the signatures in this request combined with the existing topology state.
+             *     - A PartyToParticipant to register the hosting relationship of the party.
+             *     Must be provided.
+             *     Required */
+            onboardingTransactions?: components["schemas"]["SignedTransaction"][];
+            /** @description Optional signatures of the combined hash of all onboarding_transactions
+             *     This may be used instead of providing signatures on each individual transaction */
+            multiHashSignatures?: components["schemas"]["Signature"][];
+            /** @description The id of the ``Identity Provider``
+             *     If not set, assume the party is managed by the default identity provider.
+             *     Optional */
+            identityProviderId: string;
+        };
+        /** AllocateExternalPartyResponse */
+        AllocateExternalPartyResponse: {
+            partyId: string;
+        };
         /**
          * AllocatePartyRequest
          * @description Required authorization: ``HasRight(ParticipantAdmin) OR IsAuthenticatedIdentityProviderAdmin(identity_provider_id)``
@@ -753,6 +867,20 @@ export interface components {
         CanActAs1: {
             party: string;
         };
+        /** CanExecuteAs */
+        CanExecuteAs: {
+            value: components["schemas"]["CanExecuteAs1"];
+        };
+        /** CanExecuteAs */
+        CanExecuteAs1: {
+            party: string;
+        };
+        /** CanExecuteAsAnyParty */
+        CanExecuteAsAnyParty: {
+            value: components["schemas"]["CanExecuteAsAnyParty1"];
+        };
+        /** CanExecuteAsAnyParty */
+        CanExecuteAsAnyParty1: Record<string, never>;
         /** CanReadAs */
         CanReadAs: {
             value: components["schemas"]["CanReadAs1"];
@@ -1437,6 +1565,44 @@ export interface components {
              *     Optional */
             cumulative?: components["schemas"]["CumulativeFilter"][];
         };
+        /** GenerateExternalPartyTopologyRequest */
+        GenerateExternalPartyTopologyRequest: {
+            /** @description TODO(#27670) support synchronizer aliases
+             *     Required: synchronizer-id for which we are building this request. */
+            synchronizer: string;
+            /** @description Required: the actual party id will be constructed from this hint and a fingerprint of the public key */
+            partyHint: string;
+            /** @description Required: public key */
+            publicKey?: components["schemas"]["SigningPublicKey"];
+            /** @description Optional: if true, then the local participant will only be observing, not confirming. Default false. */
+            localParticipantObservationOnly: boolean;
+            /** @description Optional: other participant ids which should be confirming for this party */
+            otherConfirmingParticipantUids?: string[];
+            /**
+             * Format: int32
+             * @description Optional: Confirmation threshold >= 1 for the party. Defaults to all available confirmers (or if set to 0).
+             */
+            confirmationThreshold: number;
+            /** @description Optional: other observing participant ids for this party */
+            observingParticipantUids?: string[];
+        };
+        /**
+         * GenerateExternalPartyTopologyResponse
+         * @description Response message with topology transactions and the multi-hash to be signed.
+         */
+        GenerateExternalPartyTopologyResponse: {
+            /** @description the generated party id */
+            partyId: string;
+            /** @description the fingerprint of the supplied public key */
+            publicKeyFingerprint: string;
+            /** @description The serialized topology transactions which need to be signed and submitted as part of the allocate party process
+             *     Note that the serialization includes the versioning information. Therefore, the transaction here is serialized
+             *     as an `UntypedVersionedMessage` which in turn contains the serialized `TopologyTransaction` in the version
+             *     supported by the synchronizer. */
+            topologyTransactions?: string[];
+            /** @description the multi-hash which may be signed instead of each individual transaction */
+            multiHash: string;
+        };
         /**
          * GetActiveContractsRequest
          * @description If the given offset is different than the ledger end, and there are (un)assignments in-flight at the given offset,
@@ -2195,6 +2361,15 @@ export interface components {
             /** @description When true, the response will contain additional details on how the transaction was encoded and hashed
              *     This can be useful for troubleshooting of hash mismatches. Should only be used for debugging. */
             verboseHashing: boolean;
+            /** @description Maximum timestamp at which the transaction can be recorded onto the ledger via the synchronizer specified in the `PrepareSubmissionResponse`.
+             *     If submitted after it will be rejected even if otherwise valid, in which case it needs to be prepared and signed again
+             *     with a new valid max_record_time.
+             *     Use this to limit the time-to-life of a prepared transaction,
+             *     which is useful to know when it can definitely not be accepted
+             *     anymore and resorting to preparing another transaction for the same
+             *     intent is safe again.
+             *     Optional */
+            maxRecordTime?: string;
         };
         /**
          * JsPrepareSubmissionResponse
@@ -2454,6 +2629,10 @@ export interface components {
          */
         Kind: {
             CanActAs: components["schemas"]["CanActAs"];
+        } | {
+            CanExecuteAs: components["schemas"]["CanExecuteAs"];
+        } | {
+            CanExecuteAsAnyParty: components["schemas"]["CanExecuteAsAnyParty"];
         } | {
             CanReadAs: components["schemas"]["CanReadAs"];
         } | {
@@ -2833,6 +3012,26 @@ export interface components {
             /** @description The signing algorithm specification used to produce this signature */
             signingAlgorithmSpec: string;
         };
+        /** SignedTransaction */
+        SignedTransaction: {
+            transaction: string;
+            signatures?: components["schemas"]["Signature"][];
+        };
+        /** SigningPublicKey */
+        SigningPublicKey: {
+            /**
+             * @description The serialization format of the public key
+             * @example CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO
+             */
+            format: string;
+            /** @description Serialized public key in the format specified above */
+            keyData: string;
+            /**
+             * @description The key specification
+             * @example SIGNING_KEY_SPEC_EC_CURVE25519
+             */
+            keySpec: string;
+        };
         /**
          * SinglePartySignatures
          * @description Signatures provided by a single party
@@ -3951,6 +4150,46 @@ export interface operations {
             };
         };
     };
+    postV2PartiesExternalAllocate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AllocateExternalPartyRequest"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AllocateExternalPartyResponse"];
+                };
+            };
+            /** @description Invalid value for: body, Invalid value for: headers */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsCantonError"];
+                };
+            };
+        };
+    };
     "getV2PartiesParticipant-id": {
         parameters: {
             query?: never;
@@ -4070,6 +4309,46 @@ export interface operations {
             };
         };
     };
+    "postV2PartiesExternalGenerate-topology": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GenerateExternalPartyTopologyRequest"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GenerateExternalPartyTopologyResponse"];
+                };
+            };
+            /** @description Invalid value for: body, Invalid value for: headers */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsCantonError"];
+                };
+            };
+        };
+    };
     "postV2StateActive-contracts": {
         parameters: {
             query?: {
@@ -4117,8 +4396,8 @@ export interface operations {
     };
     "getV2StateConnected-synchronizers": {
         parameters: {
-            query: {
-                party: string;
+            query?: {
+                party?: string;
                 participantId?: string;
             };
             header?: never;
@@ -4226,6 +4505,51 @@ export interface operations {
             };
         };
     };
+    postV2Updates: {
+        parameters: {
+            query?: {
+                /** @description maximum number of elements to return, this param is ignored if is bigger than server setting */
+                limit?: number;
+                /** @description timeout to complete and send result if no new elements are received (for open ended streams) */
+                stream_idle_timeout_ms?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GetUpdatesRequest"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsGetUpdatesResponse"][];
+                };
+            };
+            /** @description Invalid value for: body, Invalid value for: query parameter limit, Invalid value for: query parameter stream_idle_timeout_ms, Invalid value for: headers */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JsCantonError"];
+                };
+            };
+        };
+    };
     postV2UpdatesFlats: {
         parameters: {
             query?: {