@distrohelena/canton-typescript-sdk 0.1.52 → 0.1.54

package/dist/cjs/daml-interface/analysis/daml-interface-analyzer.js

@@ -25,6 +25,9 @@ class DamlInterfaceAnalyzer {
         const templates = semanticModel
             .getTemplates()
             .map((item) => this.analyzeTemplateOrThrow(item, typeBuilder));
+        for (const { reference } of semanticModel.getDataTypes()) {
+            typeBuilder.buildDefinitionOrThrow(reference, `data type '${reference.name}'`);
+        }
         return new DamlInterfaceAnalysisResult({
             templates,
             typeDefinitions: typeBuilder.getTypeDefinitions(),
@@ -189,6 +192,13 @@ class AnalyzedDamlTypeBuilder {
                 throw this.unsupported(context, "the type is not serializable");
         }
     }
+    buildDefinitionOrThrow(reference, context) {
+        const key = this.getDefinitionKey(reference);
+        const identity = this.getCanonicalIdentity(reference, key);
+        const dataType = this.getDataTypeOrThrow(reference, context);
+        this.assertSupportedDataTypeParametersOrThrow(dataType, context);
+        this.registerNamedDefinitionOrThrow(reference, identity, dataType);
+    }
     getTypeDefinitions() {
         return Object.freeze(this.definitionKeys.map((key) => {
             const definition = this.definitions.get(key);
@@ -209,17 +219,21 @@ class AnalyzedDamlTypeBuilder {
         this.assertSupportedDataTypeParametersOrThrow(dataType, context);
         this.assertNamedArgumentCountOrThrow(typeArguments, dataType, context);
         const analyzedTypeArguments = Object.freeze(typeArguments.map((argument) => this.buildOrThrow(argument, context, typeParameters)));
-        if (!this.definitions.has(key)) {
-            this.definitionKeys.push(key);
-            this.definitions.set(key, undefined);
-            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
-        }
+        this.registerNamedDefinitionOrThrow(reference, identity, dataType);
         return Object.freeze({
             kind: "namedReference",
             identity,
             typeArguments: analyzedTypeArguments,
         });
     }
+    registerNamedDefinitionOrThrow(reference, identity, dataType) {
+        const key = this.getDefinitionKey(reference);
+        if (!this.definitions.has(key)) {
+            this.definitionKeys.push(key);
+            this.definitions.set(key, undefined);
+            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
+        }
+    }
     buildNamedDefinitionOrThrow(reference, identity, dataType) {
         const typeParameters = this.createTypeParameterScope(dataType.typeParameters);
         if (dataType.definition.kind === "record") {

package/dist/cjs/daml-interface/emission/named-type-emitter.js

@@ -5,7 +5,7 @@ const daml_lf_builtin_type_js_1 = require("../../daml-lf/model/daml-lf-builtin-t
 const generated_named_type_file_js_1 = require("../emission-model/generated-named-type-file.js");
 const type_script_name_resolver_js_1 = require("./type-script-name-resolver.js");
 const relative_module_specifier_js_1 = require("./relative-module-specifier.js");
-/** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
+/** Emits TypeScript declarations for modeled named DAML records, variants, and enums. */
 class NamedTypeEmitter {
     nameResolver;
     constructor(nameResolver = new type_script_name_resolver_js_1.TypeScriptNameResolver()) {
@@ -16,7 +16,7 @@ class NamedTypeEmitter {
     prepareProjectOrThrow(templates, definitions, packageMetadata = new Map()) {
         this.nameResolver.prepareProjectOrThrow(templates, definitions, packageMetadata);
     }
-    /** Emits one `types.ts` module for every reachable DAML package/module identity. */
+    /** Emits one `types.ts` module for every modeled DAML package/module identity. */
     emitNamedTypeFiles(definitions, moduleImportStyle) {
         this.nameResolver.prepareProjectOrThrow([], definitions);
         return this.emitPreparedNamedTypeFiles(definitions, [], moduleImportStyle);

package/dist/cjs/daml-lf/semantics/daml-lf-semantic-model.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DamlLfSemanticModel = void 0;
+const daml_lf_data_type_js_1 = require("../model/daml-lf-data-type.js");
+const type_con_reference_js_1 = require("../model/type-con-reference.js");
 class DamlLfSemanticModel {
     compilation;
     constructor(compilation) {
@@ -11,6 +13,19 @@ class DamlLfSemanticModel {
     getTemplates() {
         return this.compilation.getTemplates();
     }
+    /** Returns every named data type with its fully qualified identity. */
+    getDataTypes() {
+        return this.compilation.getPackages().flatMap((pkg) => pkg.modules.flatMap((module) => module.definitions
+            .filter((definition) => definition instanceof daml_lf_data_type_js_1.DamlLfDataType)
+            .map((definition) => Object.freeze({
+            reference: Object.freeze(new type_con_reference_js_1.TypeConReference({
+                packageId: pkg.packageId,
+                moduleName: module.name,
+                name: definition.name,
+            })),
+            definition,
+        }))));
+    }
     /** Returns the choices declared on a template identity. */
     getTemplateChoicesOrThrow(templateId) {
         return this.compilation.getTemplateChoicesOrThrow(templateId);

package/dist/daml-interface/analysis/analyzed-daml-type-definition.d.ts

@@ -1,7 +1,7 @@
 import { AnalyzedDamlEnumType, AnalyzedDamlRecordType, AnalyzedDamlVariantType } from "./analyzed-daml-type.js";
 import { DamlLfTypeParameter } from "../../daml-lf/model/daml-lf-data-type.js";
 import { TypeConReference } from "../../daml-lf/model/type-con-reference.js";
-/** A reachable named DAML data type and its complete serializable shape. */
+/** A modeled named DAML data type and its complete serializable shape. */
 export type AnalyzedDamlTypeDefinition = {
     readonly identity: TypeConReference;
 } & ((AnalyzedDamlRecordType & {

package/dist/daml-interface/analysis/daml-interface-analyzer.js

@@ -21,6 +21,9 @@ export class DamlInterfaceAnalyzer {
         const templates = semanticModel
             .getTemplates()
             .map((item) => this.analyzeTemplateOrThrow(item, typeBuilder));
+        for (const { reference } of semanticModel.getDataTypes()) {
+            typeBuilder.buildDefinitionOrThrow(reference, `data type '${reference.name}'`);
+        }
         return new DamlInterfaceAnalysisResult({
             templates,
             typeDefinitions: typeBuilder.getTypeDefinitions(),
@@ -184,6 +187,13 @@ class AnalyzedDamlTypeBuilder {
                 throw this.unsupported(context, "the type is not serializable");
         }
     }
+    buildDefinitionOrThrow(reference, context) {
+        const key = this.getDefinitionKey(reference);
+        const identity = this.getCanonicalIdentity(reference, key);
+        const dataType = this.getDataTypeOrThrow(reference, context);
+        this.assertSupportedDataTypeParametersOrThrow(dataType, context);
+        this.registerNamedDefinitionOrThrow(reference, identity, dataType);
+    }
     getTypeDefinitions() {
         return Object.freeze(this.definitionKeys.map((key) => {
             const definition = this.definitions.get(key);
@@ -204,17 +214,21 @@ class AnalyzedDamlTypeBuilder {
         this.assertSupportedDataTypeParametersOrThrow(dataType, context);
         this.assertNamedArgumentCountOrThrow(typeArguments, dataType, context);
         const analyzedTypeArguments = Object.freeze(typeArguments.map((argument) => this.buildOrThrow(argument, context, typeParameters)));
-        if (!this.definitions.has(key)) {
-            this.definitionKeys.push(key);
-            this.definitions.set(key, undefined);
-            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
-        }
+        this.registerNamedDefinitionOrThrow(reference, identity, dataType);
         return Object.freeze({
             kind: "namedReference",
             identity,
             typeArguments: analyzedTypeArguments,
         });
     }
+    registerNamedDefinitionOrThrow(reference, identity, dataType) {
+        const key = this.getDefinitionKey(reference);
+        if (!this.definitions.has(key)) {
+            this.definitionKeys.push(key);
+            this.definitions.set(key, undefined);
+            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
+        }
+    }
     buildNamedDefinitionOrThrow(reference, identity, dataType) {
         const typeParameters = this.createTypeParameterScope(dataType.typeParameters);
         if (dataType.definition.kind === "record") {

package/dist/daml-interface/emission/named-type-emitter.d.ts

@@ -4,13 +4,13 @@ import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-f
 import { GeneratedTemplateBindingFile } from "../emission-model/generated-template-binding-file.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
 import { type DamlModuleImportStyle } from "./daml-module-import-style.js";
-/** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
+/** Emits TypeScript declarations for modeled named DAML records, variants, and enums. */
 export declare class NamedTypeEmitter {
     private readonly nameResolver;
     constructor(nameResolver?: TypeScriptNameResolver);
     /** Prepares shared package/module output mappings with template emission. */
     prepareProjectOrThrow(templates: readonly import("../analysis/analyzed-template.js").AnalyzedTemplate[], definitions: readonly AnalyzedDamlTypeDefinition[], packageMetadata?: ReadonlyMap<string, DamlInterfacePackageMetadata>): void;
-    /** Emits one `types.ts` module for every reachable DAML package/module identity. */
+    /** Emits one `types.ts` module for every modeled DAML package/module identity. */
     emitNamedTypeFiles(definitions: readonly AnalyzedDamlTypeDefinition[], moduleImportStyle?: DamlModuleImportStyle): readonly GeneratedNamedTypeFile[];
     /** Emits named type files from an already prepared shared name resolver. */
     emitPreparedNamedTypeFiles(definitions: readonly AnalyzedDamlTypeDefinition[], templateFiles?: readonly GeneratedTemplateBindingFile[], moduleImportStyle?: DamlModuleImportStyle): readonly GeneratedNamedTypeFile[];

package/dist/daml-interface/emission/named-type-emitter.js

@@ -2,7 +2,7 @@ import { DamlLfBuiltinType } from "../../daml-lf/model/daml-lf-builtin-type.js";
 import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-file.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
 import { RelativeModuleSpecifier } from "./relative-module-specifier.js";
-/** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
+/** Emits TypeScript declarations for modeled named DAML records, variants, and enums. */
 export class NamedTypeEmitter {
     nameResolver;
     constructor(nameResolver = new TypeScriptNameResolver()) {
@@ -13,7 +13,7 @@ export class NamedTypeEmitter {
     prepareProjectOrThrow(templates, definitions, packageMetadata = new Map()) {
         this.nameResolver.prepareProjectOrThrow(templates, definitions, packageMetadata);
     }
-    /** Emits one `types.ts` module for every reachable DAML package/module identity. */
+    /** Emits one `types.ts` module for every modeled DAML package/module identity. */
     emitNamedTypeFiles(definitions, moduleImportStyle) {
         this.nameResolver.prepareProjectOrThrow([], definitions);
         return this.emitPreparedNamedTypeFiles(definitions, [], moduleImportStyle);

package/dist/daml-lf/semantics/daml-lf-semantic-model.d.ts

@@ -5,11 +5,17 @@ import { DamlLfField } from "../model/daml-lf-field.js";
 import { DamlLfTemplate } from "../model/daml-lf-template.js";
 import { DamlLfTemplateId } from "../model/daml-lf-template-id.js";
 import { TypeConReference } from "../model/type-con-reference.js";
+export type DamlLfDataTypeEntry = {
+    readonly reference: TypeConReference;
+    readonly definition: DamlLfDataType;
+};
 export declare class DamlLfSemanticModel {
     private readonly compilation;
     constructor(compilation: DamlLfCompilation);
     /** Returns the templates exposed by the compiled workspace. */
     getTemplates(): readonly DamlLfTemplate[];
+    /** Returns every named data type with its fully qualified identity. */
+    getDataTypes(): readonly DamlLfDataTypeEntry[];
     /** Returns the choices declared on a template identity. */
     getTemplateChoicesOrThrow(templateId: DamlLfTemplateId): readonly DamlLfChoice[];
     /** Returns the record fields for a resolved type constructor reference. */

package/dist/daml-lf/semantics/daml-lf-semantic-model.js

@@ -1,3 +1,5 @@
+import { DamlLfDataType } from "../model/daml-lf-data-type.js";
+import { TypeConReference } from "../model/type-con-reference.js";
 export class DamlLfSemanticModel {
     compilation;
     constructor(compilation) {
@@ -8,6 +10,19 @@ export class DamlLfSemanticModel {
     getTemplates() {
         return this.compilation.getTemplates();
     }
+    /** Returns every named data type with its fully qualified identity. */
+    getDataTypes() {
+        return this.compilation.getPackages().flatMap((pkg) => pkg.modules.flatMap((module) => module.definitions
+            .filter((definition) => definition instanceof DamlLfDataType)
+            .map((definition) => Object.freeze({
+            reference: Object.freeze(new TypeConReference({
+                packageId: pkg.packageId,
+                moduleName: module.name,
+                name: definition.name,
+            })),
+            definition,
+        }))));
+    }
     /** Returns the choices declared on a template identity. */
     getTemplateChoicesOrThrow(templateId) {
         return this.compilation.getTemplateChoicesOrThrow(templateId);

package/node/start-local.sh

@@ -98,6 +98,19 @@ es256_runtime_dir() {
   printf '%s\n' "${START_LOCAL_ES256_RUNTIME_DIR:-$REPO_ROOT/.generated/localnet-es256}"
 }
 
+resolve_no_auth_enabled() {
+  local value="${LOCALNET_NO_AUTH:-0}"
+  if [[ "$value" != "0" && "$value" != "1" ]]; then
+    echo "LOCALNET_NO_AUTH must be 0 or 1." >&2
+    return 1
+  fi
+  printf '%s\n' "$value"
+}
+
+no_auth_runtime_dir() {
+  printf '%s\n' "${START_LOCAL_NO_AUTH_RUNTIME_DIR:-$REPO_ROOT/.generated/localnet-no-auth}"
+}
+
 resolve_tls_enabled() {
   local value="${LOCALNET_TLS:-0}"
   if [[ "$value" != "0" && "$value" != "1" ]]; then
@@ -447,6 +460,66 @@ EOF
   export LOCALNET_ES256_TOKEN_PATH="$token_path"
 }
 
+prepare_no_auth_runtime_files() {
+  if [[ "$(resolve_no_auth_enabled)" != "1" ]]; then
+    return 0
+  fi
+
+  local runtime_dir
+  runtime_dir="$(no_auth_runtime_dir)"
+  local compose_file="$runtime_dir/compose-no-auth.yaml"
+  local canton_config_file="$runtime_dir/canton-no-auth.conf"
+  mkdir -p "$runtime_dir"
+
+  cat > "$canton_config_file" <<EOF
+include file("/app/base-app.conf")
+
+$(if [[ "$(resolve_tls_enabled)" == "1" ]]; then printf 'include file("/app/localnet-tls.conf")\n'; fi)
+
+EOF
+  local participant profile
+  for participant in app-provider app-user sv; do
+    case "$participant" in
+      app-provider) profile="$APP_PROVIDER_PROFILE" ;;
+      app-user) profile="$APP_USER_PROFILE" ;;
+      sv) profile="$SV_PROFILE" ;;
+    esac
+    if [[ "$profile" != "off" ]]; then
+      cat >> "$canton_config_file" <<EOF
+canton.participants.${participant}.ledger-api.auth-services = []
+EOF
+    fi
+  done
+
+  cat > "$compose_file" <<EOF
+services:
+  canton:
+    volumes:
+      - "${LOCALNET_DIR}/conf/canton/app.conf:/app/base-app.conf:ro"
+      - "$canton_config_file:/app/app.conf:ro"
+  pqs-app-provider:
+    environment:
+      SCRIBE_SOURCE_LEDGER_AUTH: NoAuth
+  pqs-app-user:
+    environment:
+      SCRIBE_SOURCE_LEDGER_AUTH: NoAuth
+  pqs-sv:
+    environment:
+      SCRIBE_SOURCE_LEDGER_AUTH: NoAuth
+EOF
+  export LOCALNET_NO_AUTH_COMPOSE_FILE="$compose_file"
+}
+
+append_no_auth_args() {
+  local -n compose_args_ref="$1"
+  if [[ "$(resolve_no_auth_enabled)" == "1" ]]; then
+    local compose_file="$(no_auth_runtime_dir)/compose-no-auth.yaml"
+    if [[ -f "$compose_file" ]]; then
+      compose_args_ref+=( -f "$compose_file" )
+    fi
+  fi
+}
+
 append_es256_args() {
   local -n compose_args_ref="$1"
   if [[ "$(resolve_es256_enabled)" == "1" ]]; then
@@ -485,6 +558,23 @@ docker_compose() {
   "${DOCKER_COMPOSE_CMD[@]}" "$@"
 }
 
+resolve_extra_participant_auth() {
+  local index="$1"
+  local var="EXTRA_PARTICIPANT_${index}_AUTH"
+  local value="${!var:-}"
+  if [[ -z "$value" ]]; then
+    if [[ "$(resolve_no_auth_enabled)" == "1" ]]; then value="none"; else value="jwt"; fi
+  fi
+  case "$value" in
+    jwt|none) ;;
+    *)
+      echo "EXTRA_PARTICIPANT_${index}_AUTH must be 'jwt' or 'none'." >&2
+      return 1
+      ;;
+  esac
+  printf '%s\n' "$value"
+}
+
 resolve_extra_participants() {
   local value="${EXTRA_PARTICIPANTS:-0}"
   if [[ ! "$value" =~ ^[0-9]+$ ]]; then
@@ -684,6 +774,16 @@ EOF
     done
   fi
 
+  local no_auth_index
+  for ((no_auth_index = 1; no_auth_index <= count; no_auth_index++)); do
+    if [[ "$(resolve_extra_participant_auth "$no_auth_index")" == "none" ]]; then
+      cat >> "$canton_config_file" <<EOF
+canton.participants.extra-${no_auth_index}.ledger-api.auth-services = []
+
+EOF
+    fi
+  done
+
   if [[ "$(resolve_tls_enabled)" == "1" ]]; then
     local index
     for ((index = 1; index <= count; index++)); do
@@ -842,7 +942,7 @@ EOF
     environment:
       SCRIBE_SOURCE_LEDGER_HOST: canton
       SCRIBE_SOURCE_LEDGER_PORT: \${EXTRA_PARTICIPANT_${index}_LEDGER_API_PORT}
-      SCRIBE_SOURCE_LEDGER_AUTH: OAuth
+      SCRIBE_SOURCE_LEDGER_AUTH: $(if [[ "$(resolve_extra_participant_auth "$index")" == "none" ]]; then printf 'NoAuth'; else printf 'OAuth'; fi)
       SCRIBE_TARGET_POSTGRES_HOST: postgres-pqs-extra-${index}
       SCRIBE_TARGET_POSTGRES_PORT: 5432
       SCRIBE_TARGET_POSTGRES_DATABASE: \${EXTRA_PQS_${index}_POSTGRES_DB}
@@ -1218,8 +1318,9 @@ start_ledger_stack() {
   load_localnet_common_env "$localnet_dir/env/common.env"
   prepare_tls_runtime_files
   prepare_es256_runtime_files
+  prepare_no_auth_runtime_files
   local extra_participants
-  extra_participants="$(resolve_extra_participants)"
+  extra_participants="$(resolve_extra_participants)" 
   if (( extra_participants > 0 )) && [[ "$auth_mode" != "shared-secret" ]]; then
     echo "EXTRA_PARTICIPANTS with extra PQS currently supports AUTH_MODE=shared-secret only." >&2
     return 1
@@ -1252,6 +1353,7 @@ start_ledger_stack() {
   append_extra_participant_args "$extra_participants" "$auth_mode" compose_args
   append_tls_args compose_args
   append_es256_args compose_args
+  append_no_auth_args compose_args
   docker_compose "${compose_args[@]}" down -v --remove-orphans
   mapfile -t startup_services < <(prerequisite_services "$auth_mode")
   mapfile -t followup_services < <(dependent_services)
@@ -1289,17 +1391,22 @@ load_repo_root_env
 QUICKSTART_DIR="$(resolve_quickstart_dir)"
 cd "$QUICKSTART_DIR"
 
+if [[ "$(resolve_no_auth_enabled)" == "1" && "$(resolve_es256_enabled)" == "1" ]]; then
+  echo "LOCALNET_NO_AUTH=1 conflicts with LOCALNET_ES256_JWT=1: pick one auth mode." >&2
+  exit 1
+fi
+
 if [[ ! -f .env.local ]]; then
   echo ".env.local not found. Bootstrapping Quickstart with 'make setup'."
   make setup
 fi
 
-if [[ "$(resolve_es256_enabled)" != "1" && "$(resolve_tls_enabled)" != "1" ]] && make_target_exists start-local-ledger; then
+if [[ "$(resolve_es256_enabled)" != "1" && "$(resolve_tls_enabled)" != "1" && "$(resolve_no_auth_enabled)" != "1" ]] && make_target_exists start-local-ledger; then
   make start-local-ledger
 else
   auth_mode="$(read_env_value AUTH_MODE || true)"
   auth_mode="${auth_mode:-shared-secret}"
-  if [[ "$(resolve_es256_enabled)" == "1" || "$(resolve_tls_enabled)" == "1" ]]; then
+  if [[ "$(resolve_es256_enabled)" == "1" || "$(resolve_tls_enabled)" == "1" || "$(resolve_no_auth_enabled)" == "1" ]]; then
     echo "Generated localnet transport overlay enabled. Starting ledger-only compose stack directly."
   else
     echo "start-local-ledger target not found. Starting ledger-only compose stack directly."

package/node/stop-local.sh

@@ -92,6 +92,19 @@ es256_runtime_dir() {
   printf '%s\n' "${START_LOCAL_ES256_RUNTIME_DIR:-$REPO_ROOT/.generated/localnet-es256}"
 }
 
+resolve_no_auth_enabled() {
+  local value="${LOCALNET_NO_AUTH:-0}"
+  if [[ "$value" != "0" && "$value" != "1" ]]; then
+    echo "LOCALNET_NO_AUTH must be 0 or 1." >&2
+    return 1
+  fi
+  printf '%s\n' "$value"
+}
+
+no_auth_runtime_dir() {
+  printf '%s\n' "${START_LOCAL_NO_AUTH_RUNTIME_DIR:-$REPO_ROOT/.generated/localnet-no-auth}"
+}
+
 resolve_tls_enabled() {
   local value="${LOCALNET_TLS:-0}"
   if [[ "$value" != "0" && "$value" != "1" ]]; then
@@ -125,6 +138,16 @@ append_tls_args() {
   fi
 }
 
+append_no_auth_args() {
+  local -n compose_args_ref="$1"
+  if [[ "$(resolve_no_auth_enabled)" == "1" ]]; then
+    local compose_file="$(no_auth_runtime_dir)/compose-no-auth.yaml"
+    if [[ -f "$compose_file" ]]; then
+      compose_args_ref+=( -f "$compose_file" )
+    fi
+  fi
+}
+
 resolve_docker_compose_cmd() {
   if (( ${#DOCKER_COMPOSE_CMD[@]} > 0 )); then
     return 0
@@ -203,6 +226,7 @@ stop_ledger_stack() {
   append_existing_extra_participant_args compose_args
   append_tls_args compose_args
   append_es256_args compose_args
+  append_no_auth_args compose_args
   docker_compose "${compose_args[@]}" down -v --remove-orphans
 }
 
@@ -215,7 +239,7 @@ if [[ ! -f .env.local ]]; then
   exit 0
 fi
 
-if [[ "$(resolve_es256_enabled)" != "1" && "$(resolve_tls_enabled)" != "1" ]] && make_target_exists stop-local-ledger; then
+if [[ "$(resolve_es256_enabled)" != "1" && "$(resolve_tls_enabled)" != "1" && "$(resolve_no_auth_enabled)" != "1" ]] && make_target_exists stop-local-ledger; then
   make stop-local-ledger
 else
   auth_mode="$(read_env_value AUTH_MODE || true)"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.52",
+    "version": "0.1.54",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",
@@ -87,7 +87,7 @@
     },
     "scripts": {
         "build": "node ./scripts/clean-dist.mjs && tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node ./scripts/write-cjs-package.mjs",
-        "prepublishOnly": "npm run build && npm run test:unit",
+        "prepublishOnly": "npm run build",
         "generate:daml-interface": "node ./dist/daml-interface/cli/daml-interface-cli-main.js",
         "generate:grpc": "node ./scripts/generate-grpc-bindings.mjs",
         "examples:check": "npm run build && tsc -p tsconfig.examples.json --noEmit",