@c7-digital/ledger 0.0.2

package/lib/src/generated/sdk-version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "3.4.7";

package/lib/src/generated/sdk-version.js

@@ -0,0 +1,3 @@
+// Auto-generated file - do not edit manually
+// Generated from SDK version: 3.4.7
+export const SDK_VERSION = "3.4.7";

package/lib/src/index.d.ts

@@ -0,0 +1,8 @@
+export { Ledger, type LedgerOptions, createCmd, createAndExerciseCmd, exerciseCmd } from "./ledger.js";
+export { TypedHttpClient, type TypedHttpClientConfig } from "./client.js";
+export { WebSocketClient, type StreamConfig, type CompletionStreamRequest, type CompletionStreamMessage, type ActiveContractsStreamRequest, type ActiveContractsStreamMessage, type UpdatesStreamRequest, type UpdatesStreamMessage, } from "./websocket.js";
+export { type ValidationMode } from "./validation.js";
+export { type Logger, ConsoleLogger, NoOpLogger, logger, setLogger } from "./logger.js";
+export * from "./types.js";
+export * from "./valueTypes.js";
+export { SDK_VERSION } from "./generated/sdk-version.js";

package/lib/src/index.js

@@ -0,0 +1,8 @@
+// Main export for the new ledger package
+export { Ledger, createCmd, createAndExerciseCmd, exerciseCmd } from "./ledger.js";
+export { TypedHttpClient } from "./client.js";
+export { WebSocketClient, } from "./websocket.js";
+export { ConsoleLogger, NoOpLogger, logger, setLogger } from "./logger.js";
+export * from "./types.js";
+export * from "./valueTypes.js";
+export { SDK_VERSION } from "./generated/sdk-version.js";

package/lib/src/ledger.d.ts

@@ -0,0 +1,188 @@
+/**
+ * High-level Daml Ledger abstraction for Canton's OpenAPI v2 JSON API
+ *
+ * This class provides convenient, Template and Choice-aware methods for common
+ * Daml operations. It applies business logic to filter and transform raw API
+ * responses into the expected Daml types, ensuring results match the requested
+ * Template or Choice specifications.
+ *
+ * Key features:
+ * - Template-typed contract queries and creation
+ * - Choice-typed exercise operations
+ * - Automatic filtering of irrelevant data (non-active contracts, wrong templates)
+ * - Type safety with branded value.proto string types
+ * - Compatibility with @daml/types interfaces
+ *
+ * Use this for most Daml application needs. Use TypedHttpClient directly when
+ * you need access to Canton-specific endpoints or full control over API calls.
+ */
+import { ContractId, Party, Choice, InterfaceCompanion, Template, TemplateOrInterface } from "@daml/types";
+import { AllocatePartyRequest, AllocatePartyResponse, Command, CreateCommand, CreateAndExerciseCommand, CreateEvent, ExerciseCommand, Event, Interface, LedgerOffset, Stream, PartyDetails, User, MultiStream, TemplateMapping, VersionedRegistry } from "./types.js";
+import { ValidationMode } from "./validation.js";
+import { PackageIdString } from "./valueTypes.js";
+export declare function createCmd<T extends object, K = unknown>(template: Template<T, K, string>, payload: T): CreateCommand<T, K>;
+export declare function createAndExerciseCmd<T extends object, C, R, K = unknown>(template: Template<T, K, string>, payload: T, choice: Choice<T, C, R, K>, argument: C): CreateAndExerciseCommand<T, C, R, K>;
+export declare function exerciseCmd<T extends object, C, R, K = unknown>(contractId: ContractId<T>, choice: Choice<T, C, R, K>, argument: C): ExerciseCommand<T, C, R, K>;
+/**
+ * Options for the Ledger constructor
+ */
+export interface LedgerOptions {
+    /**
+     * The authentication token to use for requests
+     */
+    token: string;
+    /**
+     * The base URL for HTTP requests.
+     */
+    httpBaseUrl: string;
+    /**
+     * The base URL for WebSocket requests, derived from httpBaseUrl if not provided.
+     */
+    wsBaseUrl?: string;
+    /**
+     * The validation mode to use for requests.
+     * "throwOnError" - throw an error if validation fails
+     * "logErrors" - log errors to console/logger if validation fails
+     *
+     * The API does fail validation pretty frequently so even with "logErrors"
+     * please be prepared for some noise in the logger.
+     */
+    validation?: ValidationMode;
+    /**
+     * The path to the OpenAPI schema to use for validation
+     */
+    openApiSchemaPath?: string;
+    /**
+     * The path to the AsyncAPI schema to use for validation
+     */
+    asyncApiSchemaPath?: string;
+    /**
+     * Semi-optional version-aware template/interface registry.
+     * If provided, this function will be used instead of the default lookupTemplate.
+     * Should return VersionedLookupResult or undefined. This is required for
+     * querying and decoding interfaces views.
+     */
+    versionedRegistry?: VersionedRegistry;
+}
+/**
+ * Meant to be a simple replacement for Ledger from @daml/ledger
+ */
+export declare class Ledger {
+    private client;
+    private ledgerEndCache?;
+    private ledgerEndPromise?;
+    private tokenUserId;
+    private tokenUserInfo;
+    private httpBaseUrl;
+    private options;
+    constructor(options: LedgerOptions);
+    private generateCommandId;
+    private resolveOffset;
+    private getLedgerEnd;
+    getTokenUserId(): string;
+    getTokenUserInfo(): Promise<User | null>;
+    getTokenActAsParties(): Promise<Party[]>;
+    /**
+     * Query for the Active Contract Set of a specific template.
+     * @param template a Template instance as generated by the codegen
+     * @param atOffset Whether we want to get historical or just the current
+     *  state, default.
+     * @param includeCreatedEventBlob
+     * @param verbose
+     * @param readAsParties
+     * @returns
+     */
+    query<T extends object, K = unknown>(template: Template<T, K, PackageIdString>, atOffset?: LedgerOffset, includeCreatedEventBlob?: boolean, verbose?: boolean, readAsParties?: Party[]): Promise<CreateEvent<T, K>[]>;
+    /**
+     * Query for instances of a given interface.
+     * @param interface_
+     * @param atOffset
+     * @param includeCreatedEventBlob
+     * @param verbose
+     * @param readAsParties
+     * @returns
+     */
+    queryInterface<I extends object, K = unknown>(interface_: InterfaceCompanion<I, K, PackageIdString>, atOffset?: LedgerOffset, includeCreatedEventBlob?: boolean, verbose?: boolean, readAsParties?: Party[]): Promise<Interface<I>[]>;
+    /**
+     * Create a template
+     * @param template
+     * @param payload
+     * @param actAs
+     * @returns
+     */
+    create<T extends object, K = unknown, TTemplateId extends string = string>(template: Template<T, K, TTemplateId>, payload: T, actAs?: Party[]): Promise<CreateEvent<T, K>>;
+    /**
+     * Exercise a choice of a given contract
+     * @param choice
+     * @param contractId
+     * @param argument
+     * @param actAs
+     * @returns
+     */
+    exercise<T extends object, C, R, K = unknown>(choice: Choice<T, C, R, K>, contractId: ContractId<T>, argument: C, actAs?: Party[]): Promise<Event<object, unknown>[]>;
+    /**
+     * `submit` allows combining multiple commands into a single Canton
+     * transaction. Similar to `create` and `exercise` one can use `createCmd`
+     * and `exerciseCmd` to create commands, that are then passed to `submit`.
+     *
+     * @param commands
+     * @param actAs Defaults to the actAs parties of the user in the token.
+     * @returns Stream of events resulting from the submitted commands.
+     */
+    submit(commands: Command<any, any>[], actAs?: Party[]): Promise<Event<object, unknown>[]>;
+    private initClient;
+    /**
+     * Stream functionality using WebSockets
+     *
+     * @param template The template to stream
+     * @param readAsParties Array of parties to stream for, if not specified default to
+     *          the actAs parties of the user in the token.
+     * @param offset Optional offset to start streaming from
+     * @param skipAcs Whether to skip archived contracts
+     * @param includeCreatedEventBlob Whether to include created event blobs
+     * @returns A stream of events for the specified template
+     */
+    streamQuery<T extends object, K = unknown>(template: TemplateOrInterface<T, K>, offset?: LedgerOffset, skipAcs?: boolean, includeCreatedEventBlob?: boolean, readAsParties?: Party[]): Promise<Stream<T, K>>;
+    /**
+     * Create a type-safe MultiStream for working with multiple templates
+     *
+     * @example
+     * ```typescript
+     * // Define your template mapping
+     * type MyTemplates = {
+     *   [UserTemplate.templateId]: { contractType: UserContract, keyType: UserKey },
+     *   [AccountTemplate.templateId]: { contractType: AccountContract, keyType: AccountKey }
+     * };
+     *
+     * // Create a type-safe multi-stream
+     * const stream = await ledger.createMultiStream<MyTemplates>(
+     *   [UserTemplate, AccountTemplate],
+     *   [party]
+     * );
+     *
+     * // Use template-specific handlers with proper typing
+     * stream.onCreate(UserTemplate.templateId, (event) => {
+     *   // event.payload is typed as UserContract
+     *   logger.log("User created:", event.payload.username);
+     * });
+     *
+     * stream.onCreate(AccountTemplate.templateId, (event) => {
+     *   // event.payload is typed as AccountContract
+     *   logger.log("Account created:", event.payload.accountNumber);
+     * });
+     *
+     * stream.start();
+     * ```
+     *
+     * @param templates Array of templates to stream
+     * @param offset Optional offset to start streaming from
+     * @param includeCreatedEventBlob Whether to include created event blobs
+     * @param readAsParties Array of parties to stream for, if not specified default to
+     *          the actAs parties of the user in the token.
+     * @returns A type-safe MultiStream for working with multiple templates
+     */
+    createMultiStream<TM extends TemplateMapping>(tm: TM, offset?: LedgerOffset, skipAcs?: boolean, includeCreatedEventBlob?: boolean, readAsParties?: Party[]): Promise<MultiStream<TM>>;
+    getUserInfo(userId: string): Promise<User | null>;
+    getParties(): Promise<PartyDetails[]>;
+    allocateParty(request: AllocatePartyRequest): Promise<AllocatePartyResponse>;
+}