@distrohelena/canton-typescript-sdk 0.1.2 → 0.1.4

package/dist/client/canton-hashing-client.d.ts

@@ -1,8 +1,9 @@
+import { ExternalPartyCryptoKeyFormat } from "../core/types/external-party/external-party-crypto-key-format.js";
 export declare class CantonHashingClient {
     /** Computes a Canton multihash for the provided content and hash purpose. */
     computeHash(content: Uint8Array, purpose: number): Uint8Array;
     /** Computes a Canton multihash as lowercase hexadecimal for the provided content and hash purpose. */
     computeHashHex(content: Uint8Array, purpose: number): string;
     /** Computes the canonical Canton public-key fingerprint from serialized public key bytes. */
-    computePublicKeyFingerprint(publicKey: Uint8Array): string;
+    computePublicKeyFingerprint(publicKey: Uint8Array, format?: ExternalPartyCryptoKeyFormat): string;
 }

package/dist/client/canton-hashing-client.js

@@ -1,5 +1,4 @@
-import { computeCantonHash, computeCantonHashHex, } from "../core/hashing/canton-hash.js";
-import { CantonHashPurpose } from "../core/types/canton-hash-purpose.js";
+import { computeCantonHash, computeCantonHashHex, computeCantonPublicKeyFingerprint, } from "../core/hashing/canton-hash.js";
 export class CantonHashingClient {
     /** Computes a Canton multihash for the provided content and hash purpose. */
     computeHash(content, purpose) {
@@ -10,7 +9,7 @@ export class CantonHashingClient {
         return computeCantonHashHex(content, purpose);
     }
     /** Computes the canonical Canton public-key fingerprint from serialized public key bytes. */
-    computePublicKeyFingerprint(publicKey) {
-        return computeCantonHashHex(publicKey, CantonHashPurpose.publicKeyFingerprint);
+    computePublicKeyFingerprint(publicKey, format) {
+        return computeCantonPublicKeyFingerprint(publicKey, format) ?? "";
     }
 }

package/dist/core/hashing/canton-hash.d.ts

@@ -1,3 +1,3 @@
 export declare function computeCantonHash(content: Uint8Array, purpose: number): Uint8Array;
 export declare function computeCantonHashHex(content: Uint8Array, purpose: number): string;
-export declare function computeCantonPublicKeyFingerprint(publicKey: Uint8Array | undefined): string | undefined;
+export declare function computeCantonPublicKeyFingerprint(publicKey: Uint8Array | undefined, format?: string): string | undefined;

package/dist/core/hashing/canton-hash.js

@@ -1,6 +1,11 @@
 import { createHash } from "node:crypto";
 import { CantonHashPurpose } from "../types/canton-hash-purpose.js";
 const sha256MultihashPrefix = new Uint8Array([0x12, 0x20]);
+const asn1SequenceTag = 0x30;
+const asn1ObjectIdentifierTag = 0x06;
+const asn1BitStringTag = 0x03;
+const ed25519ObjectIdentifier = new Uint8Array([0x2b, 0x65, 0x70]);
+const derX509SubjectPublicKeyInfoFormat = "derX509SubjectPublicKeyInfo";
 export function computeCantonHash(content, purpose) {
     const purposePrefix = Buffer.alloc(4);
     purposePrefix.writeUInt32BE(purpose, 0);
@@ -16,9 +21,99 @@ export function computeCantonHash(content, purpose) {
 export function computeCantonHashHex(content, purpose) {
     return Buffer.from(computeCantonHash(content, purpose)).toString("hex");
 }
-export function computeCantonPublicKeyFingerprint(publicKey) {
+export function computeCantonPublicKeyFingerprint(publicKey, format) {
     if (publicKey === undefined || publicKey.length === 0) {
         return undefined;
     }
-    return computeCantonHashHex(publicKey, CantonHashPurpose.publicKeyFingerprint);
+    return computeCantonHashHex(normalizePublicKeyForFingerprint(publicKey, format), CantonHashPurpose.publicKeyFingerprint);
+}
+function normalizePublicKeyForFingerprint(publicKey, format) {
+    if (format !== derX509SubjectPublicKeyInfoFormat) {
+        return publicKey;
+    }
+    return tryExtractEd25519PublicKeyFromSpki(publicKey) ?? publicKey;
+}
+function tryExtractEd25519PublicKeyFromSpki(spki) {
+    try {
+        const outer = readAsn1Element(spki, 0);
+        if (outer.tag !== asn1SequenceTag) {
+            return undefined;
+        }
+        const algorithm = readAsn1Element(spki, outer.contentOffset);
+        if (algorithm.tag !== asn1SequenceTag) {
+            return undefined;
+        }
+        const algorithmIdentifier = readAsn1Element(spki, algorithm.contentOffset);
+        if (algorithmIdentifier.tag !== asn1ObjectIdentifierTag
+            || !bytesEqual(spki.subarray(algorithmIdentifier.contentOffset, algorithmIdentifier.endOffset), ed25519ObjectIdentifier)) {
+            return undefined;
+        }
+        const subjectPublicKey = readAsn1Element(spki, algorithm.endOffset);
+        if (subjectPublicKey.tag !== asn1BitStringTag) {
+            return undefined;
+        }
+        const bitString = spki.subarray(subjectPublicKey.contentOffset, subjectPublicKey.endOffset);
+        if (bitString.length !== 33 || bitString[0] !== 0) {
+            return undefined;
+        }
+        return bitString.subarray(1);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readAsn1Element(bytes, offset) {
+    if (offset + 2 > bytes.length) {
+        throw new Error("ASN.1 element header is truncated.");
+    }
+    const tag = bytes[offset];
+    const lengthResult = readAsn1Length(bytes, offset + 1);
+    const contentOffset = lengthResult.nextOffset;
+    const endOffset = contentOffset + lengthResult.length;
+    if (endOffset > bytes.length) {
+        throw new Error("ASN.1 element content is truncated.");
+    }
+    return {
+        tag,
+        contentOffset,
+        endOffset,
+    };
+}
+function readAsn1Length(bytes, offset) {
+    if (offset >= bytes.length) {
+        throw new Error("ASN.1 length is truncated.");
+    }
+    const firstByte = bytes[offset];
+    if ((firstByte & 0x80) === 0) {
+        return {
+            length: firstByte,
+            nextOffset: offset + 1,
+        };
+    }
+    const lengthByteCount = firstByte & 0x7f;
+    if (lengthByteCount === 0 || lengthByteCount > 4) {
+        throw new Error("ASN.1 length encoding is unsupported.");
+    }
+    if (offset + 1 + lengthByteCount > bytes.length) {
+        throw new Error("ASN.1 long-form length is truncated.");
+    }
+    let length = 0;
+    for (let index = 0; index < lengthByteCount; index += 1) {
+        length = (length << 8) | bytes[offset + 1 + index];
+    }
+    return {
+        length,
+        nextOffset: offset + 1 + lengthByteCount,
+    };
+}
+function bytesEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index] !== right[index]) {
+            return false;
+        }
+    }
+    return true;
 }

package/dist/core/types/commands/create-and-exercise-command.d.ts

@@ -0,0 +1,12 @@
+export declare class CreateAndExerciseCommand {
+    readonly templateId: string;
+    readonly payload: Record<string, unknown>;
+    readonly choice: string;
+    readonly argument: unknown;
+    constructor(init: {
+        templateId: string;
+        payload: Record<string, unknown>;
+        choice: string;
+        argument: unknown;
+    });
+}

package/dist/core/types/commands/create-and-exercise-command.js

@@ -0,0 +1,19 @@
+import { ValidationError } from "../../errors/validation-error.js";
+export class CreateAndExerciseCommand {
+    templateId;
+    payload;
+    choice;
+    argument;
+    constructor(init) {
+        if (!init.templateId) {
+            throw new ValidationError("create-and-exercise commands require a templateId");
+        }
+        if (!init.choice) {
+            throw new ValidationError("create-and-exercise commands require a choice");
+        }
+        this.templateId = init.templateId;
+        this.payload = init.payload;
+        this.choice = init.choice;
+        this.argument = init.argument;
+    }
+}

package/dist/core/types/commands/create-command.js

@@ -1,7 +1,11 @@
+import { ValidationError } from "../../errors/validation-error.js";
 export class CreateCommand {
     templateId;
     payload;
     constructor(init) {
+        if (!init.templateId) {
+            throw new ValidationError("create commands require a templateId");
+        }
         this.templateId = init.templateId;
         this.payload = init.payload;
     }

package/dist/core/types/commands/exercise-by-key-command.d.ts

@@ -0,0 +1,12 @@
+export declare class ExerciseByKeyCommand {
+    readonly templateId: string;
+    readonly contractKey: unknown;
+    readonly choice: string;
+    readonly argument: unknown;
+    constructor(init: {
+        templateId: string;
+        contractKey: unknown;
+        choice: string;
+        argument: unknown;
+    });
+}

package/dist/core/types/commands/exercise-by-key-command.js

@@ -0,0 +1,22 @@
+import { ValidationError } from "../../errors/validation-error.js";
+export class ExerciseByKeyCommand {
+    templateId;
+    contractKey;
+    choice;
+    argument;
+    constructor(init) {
+        if (!init.templateId) {
+            throw new ValidationError("exercise-by-key commands require a templateId");
+        }
+        if (init.contractKey === undefined) {
+            throw new ValidationError("exercise-by-key commands require a contractKey");
+        }
+        if (!init.choice) {
+            throw new ValidationError("exercise-by-key commands require a choice");
+        }
+        this.templateId = init.templateId;
+        this.contractKey = init.contractKey;
+        this.choice = init.choice;
+        this.argument = init.argument;
+    }
+}

package/dist/core/types/commands/exercise-command.d.ts

@@ -0,0 +1,12 @@
+export declare class ExerciseCommand {
+    readonly templateId: string;
+    readonly contractId: string;
+    readonly choice: string;
+    readonly argument: unknown;
+    constructor(init: {
+        templateId: string;
+        contractId: string;
+        choice: string;
+        argument: unknown;
+    });
+}

package/dist/core/types/commands/exercise-command.js

@@ -0,0 +1,22 @@
+import { ValidationError } from "../../errors/validation-error.js";
+export class ExerciseCommand {
+    templateId;
+    contractId;
+    choice;
+    argument;
+    constructor(init) {
+        if (!init.templateId) {
+            throw new ValidationError("exercise commands require a templateId");
+        }
+        if (!init.contractId) {
+            throw new ValidationError("exercise commands require a contractId");
+        }
+        if (!init.choice) {
+            throw new ValidationError("exercise commands require a choice");
+        }
+        this.templateId = init.templateId;
+        this.contractId = init.contractId;
+        this.choice = init.choice;
+        this.argument = init.argument;
+    }
+}

package/dist/core/types/commands/ledger-command.d.ts

@@ -0,0 +1,5 @@
+import { CreateAndExerciseCommand } from "./create-and-exercise-command.js";
+import { CreateCommand } from "./create-command.js";
+import { ExerciseByKeyCommand } from "./exercise-by-key-command.js";
+import { ExerciseCommand } from "./exercise-command.js";
+export type LedgerCommand = CreateCommand | ExerciseCommand | ExerciseByKeyCommand | CreateAndExerciseCommand;

package/dist/core/types/commands/ledger-command.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/requests/submit-command-request.d.ts

@@ -1,13 +1,13 @@
-import { CreateCommand } from "../commands/create-command.js";
+import { LedgerCommand } from "../commands/ledger-command.js";
 export declare class SubmitCommandRequest {
     readonly applicationId: string;
     readonly actAs: readonly string[];
     readonly readAs: readonly string[];
-    readonly command: CreateCommand;
+    readonly command: LedgerCommand;
     constructor(init: {
         applicationId: string;
         actAs: readonly string[];
         readAs?: readonly string[];
-        command: CreateCommand;
+        command: LedgerCommand;
     });
 }

package/dist/index.d.ts

@@ -180,7 +180,11 @@ export { VettedPackage } from "./core/types/vetted-package.js";
 export { VettedPackages } from "./core/types/vetted-packages.js";
 export { PreparedTopologyTransaction } from "./core/types/topology/prepared-topology-transaction.js";
 export { SignedTopologyTransaction } from "./core/types/topology/signed-topology-transaction.js";
+export { CreateAndExerciseCommand } from "./core/types/commands/create-and-exercise-command.js";
 export { CreateCommand } from "./core/types/commands/create-command.js";
+export { ExerciseByKeyCommand } from "./core/types/commands/exercise-by-key-command.js";
+export { ExerciseCommand } from "./core/types/commands/exercise-command.js";
+export type { LedgerCommand } from "./core/types/commands/ledger-command.js";
 export { AddTopologyTransactionsRequest } from "./core/types/requests/add-topology-transactions-request.js";
 export { AllocateExternalPartyRequest } from "./core/types/requests/allocate-external-party-request.js";
 export { AllocatePartyRequest } from "./core/types/requests/allocate-party-request.js";

package/dist/index.js

@@ -175,7 +175,10 @@ export { VettedPackage } from "./core/types/vetted-package.js";
 export { VettedPackages } from "./core/types/vetted-packages.js";
 export { PreparedTopologyTransaction } from "./core/types/topology/prepared-topology-transaction.js";
 export { SignedTopologyTransaction } from "./core/types/topology/signed-topology-transaction.js";
+export { CreateAndExerciseCommand } from "./core/types/commands/create-and-exercise-command.js";
 export { CreateCommand } from "./core/types/commands/create-command.js";
+export { ExerciseByKeyCommand } from "./core/types/commands/exercise-by-key-command.js";
+export { ExerciseCommand } from "./core/types/commands/exercise-command.js";
 export { AddTopologyTransactionsRequest } from "./core/types/requests/add-topology-transactions-request.js";
 export { AllocateExternalPartyRequest } from "./core/types/requests/allocate-external-party-request.js";
 export { AllocatePartyRequest } from "./core/types/requests/allocate-party-request.js";

package/dist/services/commands/command-payload-builder.js

@@ -1,11 +1,49 @@
+import { CreateAndExerciseCommand } from "../../core/types/commands/create-and-exercise-command.js";
+import { CreateCommand } from "../../core/types/commands/create-command.js";
+import { ExerciseByKeyCommand } from "../../core/types/commands/exercise-by-key-command.js";
+import { ExerciseCommand } from "../../core/types/commands/exercise-command.js";
 export function buildCanonicalCommandPayload(request) {
     return new TextEncoder().encode(JSON.stringify({
         applicationId: request.applicationId,
         actAs: request.actAs,
         readAs: request.readAs,
-        command: {
-            templateId: request.command.templateId,
-            payload: request.command.payload,
-        },
+        command: mapCanonicalCommand(request.command),
     }));
 }
+function mapCanonicalCommand(command) {
+    if (command instanceof CreateCommand) {
+        return {
+            kind: "create",
+            templateId: command.templateId,
+            payload: command.payload,
+        };
+    }
+    if (command instanceof ExerciseCommand) {
+        return {
+            kind: "exercise",
+            templateId: command.templateId,
+            contractId: command.contractId,
+            choice: command.choice,
+            argument: command.argument,
+        };
+    }
+    if (command instanceof ExerciseByKeyCommand) {
+        return {
+            kind: "exerciseByKey",
+            templateId: command.templateId,
+            contractKey: command.contractKey,
+            choice: command.choice,
+            argument: command.argument,
+        };
+    }
+    if (command instanceof CreateAndExerciseCommand) {
+        return {
+            kind: "createAndExercise",
+            templateId: command.templateId,
+            payload: command.payload,
+            choice: command.choice,
+            argument: command.argument,
+        };
+    }
+    return {};
+}

package/dist/transports/grpc/mappers/commands-mapper.js

@@ -1,5 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { ValidationError } from "../../../core/errors/validation-error.js";
+import { CreateAndExerciseCommand } from "../../../core/types/commands/create-and-exercise-command.js";
+import { CreateCommand } from "../../../core/types/commands/create-command.js";
+import { ExerciseByKeyCommand } from "../../../core/types/commands/exercise-by-key-command.js";
+import { ExerciseCommand } from "../../../core/types/commands/exercise-command.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
 export function mapGrpcSubmitCommandRequest(request, _signed) {
     return {
@@ -7,7 +11,7 @@ export function mapGrpcSubmitCommandRequest(request, _signed) {
             workflowId: "",
             userId: "",
             commandId: randomUUID(),
-            commands: [mapCreateCommand(request)],
+            commands: [mapCommand(request.command)],
             deduplicationPeriod: {
                 oneofKind: undefined,
             },
@@ -29,13 +33,58 @@ export function mapGrpcSubmitCommand(payload) {
             : payload.updateId,
     });
 }
-function mapCreateCommand(request) {
+function mapCommand(command) {
+    if (command instanceof CreateCommand) {
+        return mapCreateCommand(command);
+    }
+    if (command instanceof ExerciseCommand) {
+        return {
+            command: {
+                oneofKind: "exercise",
+                exercise: {
+                    templateId: parseTemplateIdentifier(command.templateId),
+                    contractId: command.contractId,
+                    choice: command.choice,
+                    choiceArgument: mapValue(command.argument),
+                },
+            },
+        };
+    }
+    if (command instanceof ExerciseByKeyCommand) {
+        return {
+            command: {
+                oneofKind: "exerciseByKey",
+                exerciseByKey: {
+                    templateId: parseTemplateIdentifier(command.templateId),
+                    contractKey: mapValue(command.contractKey),
+                    choice: command.choice,
+                    choiceArgument: mapValue(command.argument),
+                },
+            },
+        };
+    }
+    if (command instanceof CreateAndExerciseCommand) {
+        return {
+            command: {
+                oneofKind: "createAndExercise",
+                createAndExercise: {
+                    templateId: parseTemplateIdentifier(command.templateId),
+                    createArguments: mapRecord(command.payload),
+                    choice: command.choice,
+                    choiceArgument: mapValue(command.argument),
+                },
+            },
+        };
+    }
+    throw new ValidationError("unsupported submit command type");
+}
+function mapCreateCommand(command) {
     return {
         command: {
             oneofKind: "create",
             create: {
-                templateId: parseTemplateIdentifier(request.command.templateId),
-                createArguments: mapRecord(request.command.payload),
+                templateId: parseTemplateIdentifier(command.templateId),
+                createArguments: mapRecord(command.payload),
             },
         },
     };

package/dist/transports/grpc/mappers/topology-common-mapper.js

@@ -342,9 +342,10 @@ export function mapSdkDuration(value) {
     });
 }
 export function mapSdkSigningPublicKey(value) {
+    const format = mapSdkCryptoKeyFormat(value?.format);
     return new TopologySigningPublicKey({
-        fingerprint: computeCantonPublicKeyFingerprint(value?.publicKey),
-        format: mapSdkCryptoKeyFormat(value?.format),
+        fingerprint: computeCantonPublicKeyFingerprint(value?.publicKey, format),
+        format,
         publicKey: value?.publicKey,
         scheme: undefined,
         usage: (value?.usage ?? []).map(mapSdkSigningKeyUsage),
@@ -352,9 +353,10 @@ export function mapSdkSigningPublicKey(value) {
     });
 }
 export function mapSdkEncryptionPublicKey(value) {
+    const format = mapSdkCryptoKeyFormat(value?.format);
     return new TopologyEncryptionPublicKey({
-        fingerprint: computeCantonPublicKeyFingerprint(value?.publicKey),
-        format: mapSdkCryptoKeyFormat(value?.format),
+        fingerprint: computeCantonPublicKeyFingerprint(value?.publicKey, format),
+        format,
         publicKey: value?.publicKey,
         scheme: undefined,
         keySpec: mapSdkEncryptionKeySpec(value?.keySpec),

package/dist/transports/json/json-transport.js

@@ -5,7 +5,7 @@ import { ListKnownPartiesResponse } from "../../core/types/responses/list-known-
 import { UploadDarFileResponse } from "../../core/types/responses/upload-dar-file-response.js";
 import { NotSupportedError } from "../../core/errors/not-supported-error.js";
 import { ObjectDisposedError } from "../../core/errors/object-disposed-error.js";
-import { mapJsonSubmitCommand } from "./mappers/commands-mapper.js";
+import { mapJsonSubmitCommand, mapJsonSubmitCommandRequest, } from "./mappers/commands-mapper.js";
 import { mapJsonUploadPackage } from "./mappers/packages-mapper.js";
 import { mapJsonAllocatePartyRequest, mapJsonCreateParty, mapJsonListParties, } from "./mappers/parties-mapper.js";
 import { mapJsonQueryContracts } from "./mappers/contracts-mapper.js";
@@ -458,13 +458,7 @@ export class JsonTransport {
         if (signed) {
             throw new NotSupportedError("command signing is not supported by json transport");
         }
-        const payload = await this.httpClient.postAsync("/v1/create", {
-            templateId: request.command.templateId,
-            payload: request.command.payload,
-            applicationId: request.applicationId,
-            actAs: request.actAs,
-            readAs: request.readAs,
-        }, options);
+        const payload = await this.httpClient.postAsync("/v2/commands/submit-and-wait", mapJsonSubmitCommandRequest(request), options);
         return mapJsonSubmitCommand(payload);
     }
     throwIfDisposed() {

package/dist/transports/json/mappers/commands-mapper.d.ts

@@ -1,9 +1,20 @@
+import { SubmitCommandRequest } from "../../../core/types/requests/submit-command-request.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
+export declare function mapJsonSubmitCommandRequest(request: SubmitCommandRequest): {
+    commandId: string;
+    actAs: readonly string[];
+    readAs: readonly string[];
+    commands: unknown[];
+    applicationId?: string;
+};
 export declare function mapJsonSubmitCommand(payload: {
     result?: {
         commandId?: string;
         transactionId?: string;
+        updateId?: string;
     };
     commandId?: string;
     transactionId?: string;
+    updateId?: string;
+    completionOffset?: string;
 }): SubmitCommandResponse;

package/dist/transports/json/mappers/commands-mapper.js

@@ -1,7 +1,66 @@
+import { randomUUID } from "node:crypto";
+import { ValidationError } from "../../../core/errors/validation-error.js";
+import { CreateAndExerciseCommand } from "../../../core/types/commands/create-and-exercise-command.js";
+import { CreateCommand } from "../../../core/types/commands/create-command.js";
+import { ExerciseByKeyCommand } from "../../../core/types/commands/exercise-by-key-command.js";
+import { ExerciseCommand } from "../../../core/types/commands/exercise-command.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
+export function mapJsonSubmitCommandRequest(request) {
+    return {
+        commandId: randomUUID(),
+        actAs: request.actAs,
+        readAs: request.readAs,
+        commands: [mapJsonCommand(request.command)],
+        applicationId: request.applicationId || undefined,
+    };
+}
 export function mapJsonSubmitCommand(payload) {
     return new SubmitCommandResponse({
         commandId: payload.result?.commandId ?? payload.commandId,
-        transactionId: payload.result?.transactionId ?? payload.transactionId,
+        transactionId: payload.result?.transactionId
+            ?? payload.result?.updateId
+            ?? payload.transactionId
+            ?? payload.updateId,
     });
 }
+function mapJsonCommand(command) {
+    if (command instanceof CreateCommand) {
+        return {
+            CreateCommand: {
+                templateId: command.templateId,
+                createArguments: command.payload,
+            },
+        };
+    }
+    if (command instanceof ExerciseCommand) {
+        return {
+            ExerciseCommand: {
+                templateId: command.templateId,
+                contractId: command.contractId,
+                choice: command.choice,
+                choiceArgument: command.argument,
+            },
+        };
+    }
+    if (command instanceof ExerciseByKeyCommand) {
+        return {
+            ExerciseByKeyCommand: {
+                templateId: command.templateId,
+                contractKey: command.contractKey,
+                choice: command.choice,
+                choiceArgument: command.argument,
+            },
+        };
+    }
+    if (command instanceof CreateAndExerciseCommand) {
+        return {
+            CreateAndExerciseCommand: {
+                templateId: command.templateId,
+                createArguments: command.payload,
+                choice: command.choice,
+                choiceArgument: command.argument,
+            },
+        };
+    }
+    throw new ValidationError("unsupported submit command type");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",