@fairmint/canton-node-sdk 0.0.29

package/build/src/clients/ledger-json-api/operations/v2/updates/get-trees.d.ts

@@ -0,0 +1,215 @@
+/**
+ * @description Query update transactions tree list (blocking call)
+ * @example
+ * ```typescript
+ * const updateTrees = await client.getUpdateTrees({
+ *   beginExclusive: 1000,
+ *   endInclusive: 2000,
+ *   limit: 100,
+ *   streamIdleTimeoutMs: 5000,
+ *   updateFormat: {
+ *     includeTransactions: {
+ *       eventFormat: {
+ *         filtersByParty: {
+ *           'party1': { cumulative: [] }
+ *         },
+ *         verbose: true
+ *       },
+ *       transactionShape: 'TRANSACTION_SHAPE_ACS_DELTA'
+ *     }
+ *   }
+ * });
+ * ```
+ * @param beginExclusive - Beginning of the requested ledger section (non-negative integer)
+ * @param endInclusive - End of the requested ledger section (optional)
+ * @param limit - Maximum number of elements to return (optional)
+ * @param streamIdleTimeoutMs - Timeout to complete and send result if no new elements are received (optional)
+ * @param updateFormat - Update format for the request
+ */
+export declare const GetUpdateTrees: {
+    new (client: import("../../../../../core").BaseClient): {
+        execute(params: {
+            beginExclusive: number;
+            updateFormat: {
+                includeTransactions?: {
+                    eventFormat: {
+                        filtersByParty: Record<string, {
+                            cumulative: {
+                                identifierFilter: {
+                                    Empty: {};
+                                } | {
+                                    InterfaceFilter: {
+                                        interfaceId: string;
+                                        includeInterfaceView?: boolean | undefined;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    TemplateFilter: {
+                                        templateId: string;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    WildcardFilter: {
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                };
+                            }[];
+                        }>;
+                        filtersForAnyParty?: {
+                            cumulative: {
+                                identifierFilter: {
+                                    Empty: {};
+                                } | {
+                                    InterfaceFilter: {
+                                        interfaceId: string;
+                                        includeInterfaceView?: boolean | undefined;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    TemplateFilter: {
+                                        templateId: string;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    WildcardFilter: {
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                };
+                            }[];
+                        } | undefined;
+                        verbose?: boolean | undefined;
+                    };
+                    transactionShape: "TRANSACTION_SHAPE_ACS_DELTA" | "TRANSACTION_SHAPE_LEDGER_EFFECTS";
+                } | undefined;
+                includeReassignments?: {
+                    filtersByParty: Record<string, {
+                        cumulative: {
+                            identifierFilter: {
+                                Empty: {};
+                            } | {
+                                InterfaceFilter: {
+                                    interfaceId: string;
+                                    includeInterfaceView?: boolean | undefined;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                TemplateFilter: {
+                                    templateId: string;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                WildcardFilter: {
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            };
+                        }[];
+                    }>;
+                    filtersForAnyParty?: {
+                        cumulative: {
+                            identifierFilter: {
+                                Empty: {};
+                            } | {
+                                InterfaceFilter: {
+                                    interfaceId: string;
+                                    includeInterfaceView?: boolean | undefined;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                TemplateFilter: {
+                                    templateId: string;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                WildcardFilter: {
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            };
+                        }[];
+                    } | undefined;
+                    verbose?: boolean | undefined;
+                } | undefined;
+                includeTopologyEvents?: {
+                    includeParticipantAuthorizationEvents?: {
+                        parties?: string[] | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            endInclusive?: number | undefined;
+            limit?: number | undefined;
+            streamIdleTimeoutMs?: number | undefined;
+        }): Promise<{
+            update: {
+                JsTransactionTree: {
+                    offset: number;
+                    updateId: string;
+                    recordTime: string;
+                    effectiveAt: string;
+                    eventsById: Record<string, {
+                        CreatedTreeEvent: {
+                            value: {
+                                contractId: string;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                contractKey: string | null;
+                                createdEventBlob: string;
+                                nodeId: number;
+                                createArgument: Record<string, string | number | boolean | any[] | Record<string, any> | null>;
+                                interfaceViews: string[];
+                                witnessParties: string[];
+                                signatories: string[];
+                                observers: string[];
+                                createdAt: string;
+                                implementedInterfaces?: string[] | undefined;
+                            };
+                        };
+                    } | {
+                        ExercisedTreeEvent: {
+                            value: {
+                                contractId: string;
+                                interfaceId: string | null;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                choice: string;
+                                choiceArgument: Record<string, string | number | boolean | any[] | Record<string, any> | null>;
+                                nodeId: number;
+                                witnessParties: string[];
+                                actingParties: string[];
+                                exerciseResult: Record<string, string | number | boolean | any[] | Record<string, any> | null>;
+                                consuming: boolean;
+                                implementedInterfaces?: string[] | undefined;
+                                lastDescendantNodeId?: number | undefined;
+                            };
+                        };
+                    } | {
+                        ArchivedTreeEvent: {
+                            value: {
+                                contractId: string;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                nodeId: number;
+                                witnessParties: string[];
+                                implementedInterfaces?: string[] | undefined;
+                            };
+                        };
+                    }>;
+                    commandId?: string | undefined;
+                    workflowId?: string | undefined;
+                };
+            };
+        }[]>;
+        client: import("../../../../../core").BaseClient;
+        validateParams<T>(params: T, schema: import("zod").ZodType<T>): T;
+        makeGetRequest<T>(url: string, config?: import("../../../../../core").RequestConfig): Promise<T>;
+        makePostRequest<T>(url: string, data: unknown, config?: import("../../../../../core").RequestConfig): Promise<T>;
+        makeDeleteRequest<T>(url: string, config?: import("../../../../../core").RequestConfig): Promise<T>;
+        makePatchRequest<T>(url: string, data: unknown, config?: import("../../../../../core").RequestConfig): Promise<T>;
+        getManagedParties(): string[];
+        getPartyId(): string | undefined;
+        getApiUrl(): string;
+        buildPartyList(additionalParties?: string[]): string[];
+    };
+};
+//# sourceMappingURL=get-trees.d.ts.map

package/build/src/clients/ledger-json-api/operations/v2/updates/get-trees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-trees.d.ts","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/get-trees.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BzB,CAAC"}

package/build/src/clients/ledger-json-api/operations/v2/updates/get-trees.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUpdateTrees = void 0;
+const core_1 = require("../../../../../core");
+const operations_1 = require("../../../schemas/operations");
+/**
+ * @description Query update transactions tree list (blocking call)
+ * @example
+ * ```typescript
+ * const updateTrees = await client.getUpdateTrees({
+ *   beginExclusive: 1000,
+ *   endInclusive: 2000,
+ *   limit: 100,
+ *   streamIdleTimeoutMs: 5000,
+ *   updateFormat: {
+ *     includeTransactions: {
+ *       eventFormat: {
+ *         filtersByParty: {
+ *           'party1': { cumulative: [] }
+ *         },
+ *         verbose: true
+ *       },
+ *       transactionShape: 'TRANSACTION_SHAPE_ACS_DELTA'
+ *     }
+ *   }
+ * });
+ * ```
+ * @param beginExclusive - Beginning of the requested ledger section (non-negative integer)
+ * @param endInclusive - End of the requested ledger section (optional)
+ * @param limit - Maximum number of elements to return (optional)
+ * @param streamIdleTimeoutMs - Timeout to complete and send result if no new elements are received (optional)
+ * @param updateFormat - Update format for the request
+ */
+exports.GetUpdateTrees = (0, core_1.createApiOperation)({
+    paramsSchema: operations_1.GetUpdateTreesParamsSchema,
+    method: 'POST',
+    buildUrl: (params, apiUrl) => {
+        const baseUrl = `${apiUrl}/v2/updates/trees`;
+        const queryParams = new URLSearchParams();
+        if (params.limit !== undefined) {
+            queryParams.append('limit', params.limit.toString());
+        }
+        if (params.streamIdleTimeoutMs !== undefined) {
+            queryParams.append('stream_idle_timeout_ms', params.streamIdleTimeoutMs.toString());
+        }
+        const queryString = queryParams.toString();
+        return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+    },
+    buildRequestData: (params) => {
+        // Build request body
+        const request = {
+            beginExclusive: params.beginExclusive,
+            endInclusive: params.endInclusive,
+            updateFormat: params.updateFormat,
+        };
+        return request;
+    },
+});
+//# sourceMappingURL=get-trees.js.map

package/build/src/clients/ledger-json-api/operations/v2/updates/get-trees.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-trees.js","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/get-trees.ts"],"names":[],"mappings":";;;AAAA,8CAAyD;AACzD,4DAA+F;AAG/F;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACU,QAAA,cAAc,GAAG,IAAA,yBAAkB,EAG9C;IACA,YAAY,EAAE,uCAA0B;IACxC,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,CAAC,MAA4B,EAAE,MAAc,EAAE,EAAE;QACzD,MAAM,OAAO,GAAG,GAAG,MAAM,mBAAmB,CAAC;QAC7C,MAAM,WAAW,GAAG,IAAI,eAAe,EAAE,CAAC;QAE1C,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC/B,WAAW,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QACvD,CAAC;QACD,IAAI,MAAM,CAAC,mBAAmB,KAAK,SAAS,EAAE,CAAC;YAC7C,WAAW,CAAC,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,CAAC,CAAC;QACtF,CAAC;QAED,MAAM,WAAW,GAAG,WAAW,CAAC,QAAQ,EAAE,CAAC;QAC3C,OAAO,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,WAAW,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;IAC7D,CAAC;IACD,gBAAgB,EAAE,CAAC,MAA4B,EAAE,EAAE;QACjD,qBAAqB;QACrB,MAAM,OAAO,GAAG;YACd,cAAc,EAAE,MAAM,CAAC,cAAc;YACrC,YAAY,EAAE,MAAM,CAAC,YAAY;YACjC,YAAY,EAAE,MAAM,CAAC,YAAY;SAClC,CAAC;QAEF,OAAO,OAAO,CAAC;IACjB,CAAC;CACF,CAAC,CAAC"}

package/build/src/clients/ledger-json-api/operations/v2/updates/get-update-by-id.d.ts

@@ -0,0 +1,166 @@
+/**
+ * @description Get update by id
+ * @example
+ * ```typescript
+ * const update = await client.getUpdateById({
+ *   updateId: 'update-123',
+ *   requestingParties: ['party1', 'party2']
+ * });
+ * ```
+ * @param updateId - ID of the update to fetch
+ * @param requestingParties - Optional array of party IDs requesting the update
+ */
+export declare const GetUpdateById: {
+    new (client: import("../../../../../core").BaseClient): {
+        execute(params: {
+            updateId: string;
+            requestingParties?: string[] | undefined;
+        }): Promise<{
+            update: {
+                JsTransaction: {
+                    offset: number;
+                    updateId: string;
+                    recordTime: string;
+                    events: {
+                        synchronizerId: string;
+                        kind: {
+                            JsCreated: {
+                                contractId: string;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                contractKey: string | null;
+                                createdEventBlob: string;
+                                nodeId: number;
+                                createArgument: Record<string, string | number | boolean | any[] | Record<string, any> | null>;
+                                interfaceViews: string[];
+                                witnessParties: string[];
+                                signatories: string[];
+                                observers: string[];
+                                createdAt: string;
+                                implementedInterfaces?: string[] | undefined;
+                            };
+                        } | {
+                            JsArchived: {
+                                contractId: string;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                nodeId: number;
+                                witnessParties: string[];
+                                implementedInterfaces?: string[] | undefined;
+                            };
+                        } | {
+                            JsAssigned: {
+                                contractId: string;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                submitter: string;
+                                reassignmentId: string;
+                                source: string;
+                                target: string;
+                                nodeId: number;
+                                reassignmentCounter: number;
+                            };
+                        } | {
+                            JsUnassigned: {
+                                contractId: string;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                submitter: string;
+                                reassignmentId: string;
+                                source: string;
+                                target: string;
+                                nodeId: number;
+                                reassignmentCounter: number;
+                            };
+                        };
+                        reassignmentCounter: number;
+                    }[];
+                    effectiveAt: string;
+                    commandId?: string | undefined;
+                    workflowId?: string | undefined;
+                    traceContext?: {
+                        metadata?: Record<string, string> | undefined;
+                        traceId?: string | undefined;
+                        spanId?: string | undefined;
+                        parentSpanId?: string | undefined;
+                    } | undefined;
+                };
+            } | {
+                JsTransactionTree: {
+                    offset: number;
+                    updateId: string;
+                    recordTime: string;
+                    effectiveAt: string;
+                    eventsById: Record<string, {
+                        CreatedTreeEvent: {
+                            value: {
+                                contractId: string;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                contractKey: string | null;
+                                createdEventBlob: string;
+                                nodeId: number;
+                                createArgument: Record<string, string | number | boolean | any[] | Record<string, any> | null>;
+                                interfaceViews: string[];
+                                witnessParties: string[];
+                                signatories: string[];
+                                observers: string[];
+                                createdAt: string;
+                                implementedInterfaces?: string[] | undefined;
+                            };
+                        };
+                    } | {
+                        ExercisedTreeEvent: {
+                            value: {
+                                contractId: string;
+                                interfaceId: string | null;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                choice: string;
+                                choiceArgument: Record<string, string | number | boolean | any[] | Record<string, any> | null>;
+                                nodeId: number;
+                                witnessParties: string[];
+                                actingParties: string[];
+                                exerciseResult: Record<string, string | number | boolean | any[] | Record<string, any> | null>;
+                                consuming: boolean;
+                                implementedInterfaces?: string[] | undefined;
+                                lastDescendantNodeId?: number | undefined;
+                            };
+                        };
+                    } | {
+                        ArchivedTreeEvent: {
+                            value: {
+                                contractId: string;
+                                templateId: string;
+                                offset: number;
+                                packageName: string;
+                                nodeId: number;
+                                witnessParties: string[];
+                                implementedInterfaces?: string[] | undefined;
+                            };
+                        };
+                    }>;
+                    commandId?: string | undefined;
+                    workflowId?: string | undefined;
+                };
+            };
+        }>;
+        client: import("../../../../../core").BaseClient;
+        validateParams<T>(params: T, schema: import("zod").ZodType<T>): T;
+        makeGetRequest<T>(url: string, config?: import("../../../../../core").RequestConfig): Promise<T>;
+        makePostRequest<T>(url: string, data: unknown, config?: import("../../../../../core").RequestConfig): Promise<T>;
+        makeDeleteRequest<T>(url: string, config?: import("../../../../../core").RequestConfig): Promise<T>;
+        makePatchRequest<T>(url: string, data: unknown, config?: import("../../../../../core").RequestConfig): Promise<T>;
+        getManagedParties(): string[];
+        getPartyId(): string | undefined;
+        getApiUrl(): string;
+        buildPartyList(additionalParties?: string[]): string[];
+    };
+};
+//# sourceMappingURL=get-update-by-id.d.ts.map

package/build/src/clients/ledger-json-api/operations/v2/updates/get-update-by-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-update-by-id.d.ts","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/get-update-by-id.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCxB,CAAC"}

package/build/src/clients/ledger-json-api/operations/v2/updates/get-update-by-id.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUpdateById = void 0;
+const core_1 = require("../../../../../core");
+const operations_1 = require("../../../schemas/operations");
+/**
+ * @description Get update by id
+ * @example
+ * ```typescript
+ * const update = await client.getUpdateById({
+ *   updateId: 'update-123',
+ *   requestingParties: ['party1', 'party2']
+ * });
+ * ```
+ * @param updateId - ID of the update to fetch
+ * @param requestingParties - Optional array of party IDs requesting the update
+ */
+exports.GetUpdateById = (0, core_1.createApiOperation)({
+    paramsSchema: operations_1.GetUpdateByIdParamsSchema,
+    method: 'POST',
+    buildUrl: (_params, apiUrl) => `${apiUrl}/v2/updates/update-by-id`,
+    buildRequestData: (params, client) => {
+        // Get current party ID from client
+        const currentPartyId = client.getPartyId();
+        // Use provided parties or default to empty array
+        let requestingParties = params.requestingParties ?? [];
+        // Ensure current party ID is included
+        if (!requestingParties.includes(currentPartyId)) {
+            requestingParties.push(currentPartyId);
+        }
+        // Build request body with simplified format
+        const request = {
+            updateId: params.updateId,
+            requestingParties,
+            updateFormat: {
+                includeTransactions: {
+                    eventFormat: {
+                        verbose: true,
+                    },
+                    transactionShape: 'TRANSACTION_SHAPE_UNSPECIFIED',
+                },
+            },
+        };
+        return request;
+    },
+});
+//# sourceMappingURL=get-update-by-id.js.map

package/build/src/clients/ledger-json-api/operations/v2/updates/get-update-by-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-update-by-id.js","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/get-update-by-id.ts"],"names":[],"mappings":";;;AAAA,8CAAyD;AACzD,4DAA6F;AAG7F;;;;;;;;;;;GAWG;AACU,QAAA,aAAa,GAAG,IAAA,yBAAkB,EAG7C;IACA,YAAY,EAAE,sCAAyB;IACvC,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,CAAC,OAA4B,EAAE,MAAc,EAAE,EAAE,CAAC,GAAG,MAAM,0BAA0B;IAC/F,gBAAgB,EAAE,CAAC,MAA2B,EAAE,MAAM,EAAE,EAAE;QACxD,mCAAmC;QACnC,MAAM,cAAc,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;QAE3C,iDAAiD;QACjD,IAAI,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAEvD,sCAAsC;QACtC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YAChD,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACzC,CAAC;QAED,4CAA4C;QAC5C,MAAM,OAAO,GAAG;YACd,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,iBAAiB;YACjB,YAAY,EAAE;gBACZ,mBAAmB,EAAE;oBACnB,WAAW,EAAE;wBACX,OAAO,EAAE,IAAI;qBACd;oBACD,gBAAgB,EAAE,+BAA+B;iBAClD;aACF;SACF,CAAC;QAEF,OAAO,OAAO,CAAC;IACjB,CAAC;CACF,CAAC,CAAC"}