@ledgerhq/hw-app-canton 0.6.0 → 0.7.0-nightly.1

package/src/Canton.ts

@@ -1,19 +1,17 @@
 import type Transport from "@ledgerhq/hw-transport";
-import { UserRefusedAddress, UserRefusedOnDevice } from "@ledgerhq/errors";
+import { TransportStatusError } from "@ledgerhq/errors";
 import BIPPath from "bip32-path";
 
 const CLA = 0xe0;
 
 const P1_NON_CONFIRM = 0x00;
 const P1_CONFIRM = 0x01;
+const P1_SIGN_UNTYPED_VERSIONED_MESSAGE = 0x01;
+const P1_SIGN_PREPARED_TRANSACTION = 0x02;
 
-// P2 indicating no information.
 const P2_NONE = 0x00;
-// P2 indicating first APDU in a large request.
 const P2_FIRST = 0x01;
-// P2 indicating that this is not the last APDU in a large request.
 const P2_MORE = 0x02;
-// P2 indicating that this is the last APDU of a message in a multi message request.
 const P2_MSG_END = 0x04;
 
 const INS = {
@@ -30,6 +28,7 @@ const STATUS = {
 
 const ED25519_SIGNATURE_HEX_LENGTH = 128; // hex characters (64 bytes)
 const CANTON_SIGNATURE_HEX_LENGTH = 132; // hex characters (66 bytes with framing)
+const MAX_APDU_DATA_LENGTH = 255;
 
 export type AppConfig = {
   version: string;
@@ -38,10 +37,25 @@ export type AppConfig = {
 export type CantonAddress = {
   publicKey: string;
   address: string;
-  path: string; // TODO: check if necessary
+  path: string;
 };
 
-export type CantonSignature = string;
+export type CantonSignature = {
+  signature: string;
+  applicationSignature?: string;
+};
+
+export type CantonPreparedTransaction = {
+  damlTransaction: Uint8Array;
+  nodes: Uint8Array[];
+  metadata: Uint8Array;
+  inputContracts: Uint8Array[];
+};
+
+export type CantonUntypedVersionedMessage = {
+  transactions: string[];
+  challenge?: string;
+};
 
 /**
  * Canton BOLOS API
@@ -71,9 +85,10 @@ export default class Canton {
     const serializedPath = this.serializePath(bipPath);
 
     const p1 = display ? P1_CONFIRM : P1_NON_CONFIRM;
-    const response = await this.transport.send(CLA, INS.GET_ADDR, p1, P2_NONE, serializedPath);
 
-    const responseData = this.handleTransportResponse(response, "address");
+    const response = await this.transport.send(CLA, INS.GET_ADDR, p1, P2_NONE, serializedPath);
+    this.checkTransportResponse(response);
+    const responseData = this.extractResponseData(response);
     const { publicKey } = this.extractPublicKeyAndChainCode(responseData);
 
     const address = "canton_" + this.publicKeyToAddress(publicKey);
@@ -86,13 +101,34 @@ export default class Canton {
   }
 
   /**
-   * Sign a Canton transaction.
+   * Sign a Canton transaction
+   * using the appropriate signing method based on transaction type.
    *
    * @param path a path in BIP-32 format
-   * @param txHash the transaction hash to sign
+   * @param data either prepared transaction components, untyped versioned message, or txHash string (backwards compatibility)
    * @return the signature
    */
-  async signTransaction(path: string, txHash: string): Promise<CantonSignature> {
+  async signTransaction(
+    path: string,
+    data: CantonPreparedTransaction | CantonUntypedVersionedMessage | string,
+  ): Promise<CantonSignature> {
+    // Backwards compatibility: handle txHash string format
+    if (typeof data === "string") {
+      return this.signTxHash(path, data);
+    }
+
+    if ("damlTransaction" in data) {
+      return this.signPreparedTransaction(path, data);
+    } else {
+      return this.signUntypedVersionedMessage(path, data);
+    }
+  }
+
+  /**
+   * Sign a transaction hash (backwards compatibility)
+   * @private
+   */
+  private async signTxHash(path: string, txHash: string): Promise<CantonSignature> {
     // 1. Send the derivation path
     const bipPath = BIPPath.fromString(path).toPathArray();
     const serializedPath = this.serializePath(bipPath);
@@ -100,26 +136,187 @@ export default class Canton {
     const pathResponse = await this.transport.send(
       CLA,
       INS.SIGN,
-      P1_NON_CONFIRM,
+      P1_SIGN_UNTYPED_VERSIONED_MESSAGE,
       P2_FIRST | P2_MORE,
       serializedPath,
     );
 
-    this.handleTransportResponse(pathResponse, "transaction");
+    this.checkTransportResponse(pathResponse);
+
+    // 2. Send the transaction hash as a single transaction
+    const transactionBuffer = Buffer.from(txHash, "hex");
 
-    // 2. Send the transaction hash
     const response = await this.transport.send(
       CLA,
       INS.SIGN,
-      P1_NON_CONFIRM,
+      P1_SIGN_UNTYPED_VERSIONED_MESSAGE,
       P2_MSG_END,
-      Buffer.from(txHash, "hex"),
+      transactionBuffer,
+    );
+
+    this.checkTransportResponse(response);
+    const responseData = this.extractResponseData(response);
+    return this.parseSignatureResponse(responseData);
+  }
+
+  /**
+   * Sign a prepared Canton transaction
+   * @private
+   */
+  private async signPreparedTransaction(
+    path: string,
+    components: CantonPreparedTransaction,
+  ): Promise<CantonSignature> {
+    let responseData: Buffer | null = null;
+
+    // 1. Send the derivation path
+    const bipPath = BIPPath.fromString(path).toPathArray();
+    const serializedPath = this.serializePath(bipPath);
+
+    const pathResponse = await this.transport.send(
+      CLA,
+      INS.SIGN,
+      P1_SIGN_PREPARED_TRANSACTION,
+      P2_FIRST | P2_MORE,
+      serializedPath,
     );
 
-    const responseData = this.handleTransportResponse(response, "transaction");
-    const rawSignature = responseData.toString("hex");
+    this.checkTransportResponse(pathResponse);
+
+    // 2. Send the DAML transaction
+    await this.sendChunkedData({
+      ins: INS.SIGN,
+      p1: P1_SIGN_PREPARED_TRANSACTION,
+      payload: Buffer.from(components.damlTransaction),
+      isFinal: false,
+    });
+
+    // 3. Send each node
+    for (const [i, node] of components.nodes.entries()) {
+      this.validateUint8Array(node, `Node at index ${i}`);
+      await this.sendChunkedData({
+        ins: INS.SIGN,
+        p1: P1_SIGN_PREPARED_TRANSACTION,
+        payload: Buffer.from(node),
+        isFinal: false,
+      });
+    }
+
+    // 4. Send the metadata
+    const isFinal = components.inputContracts.length === 0;
+    const result = await this.sendChunkedData({
+      ins: INS.SIGN,
+      p1: P1_SIGN_PREPARED_TRANSACTION,
+      payload: Buffer.from(components.metadata),
+      isFinal,
+    });
+
+    if (isFinal) {
+      responseData = result;
+    }
+
+    // 5. Send each input contract - last one should return data
+    for (const [i, inputContract] of components.inputContracts.entries()) {
+      this.validateUint8Array(inputContract, `Input contract at index ${i}`);
 
-    return this.cleanSignatureFormat(rawSignature);
+      const isFinal = i === components.inputContracts.length - 1;
+      const result = await this.sendChunkedData({
+        ins: INS.SIGN,
+        p1: P1_SIGN_PREPARED_TRANSACTION,
+        payload: Buffer.from(inputContract),
+        isFinal,
+      });
+
+      if (isFinal) {
+        responseData = result;
+      }
+    }
+
+    if (!responseData) {
+      throw new Error("No response data received from device");
+    }
+
+    return this.parseSignatureResponse(responseData);
+  }
+
+  /**
+   * Sign topology transactions for Canton onboarding
+   * @private
+   */
+  private async signUntypedVersionedMessage(
+    path: string,
+    data: CantonUntypedVersionedMessage,
+  ): Promise<CantonSignature> {
+    const { transactions, challenge } = data;
+
+    if (!transactions || transactions.length === 0) {
+      throw new TypeError("At least one transaction is required");
+    }
+
+    // 1. Send the derivation path with optional challenge
+    const bipPath = BIPPath.fromString(path).toPathArray();
+    const serializedPath = this.serializePath(bipPath);
+
+    let pathData = serializedPath;
+    if (challenge) {
+      const challengeBuffer = Buffer.from(challenge, "hex");
+      pathData = Buffer.concat([serializedPath, challengeBuffer]);
+    }
+
+    const pathResponse = await this.transport.send(
+      CLA,
+      INS.SIGN,
+      P1_SIGN_UNTYPED_VERSIONED_MESSAGE,
+      P2_FIRST | P2_MORE,
+      pathData,
+    );
+
+    this.checkTransportResponse(pathResponse);
+
+    // 2. Send each transaction using chunking for large data
+    for (const [i, transaction] of transactions.entries()) {
+      if (!transaction) {
+        throw new TypeError(`Transaction at index ${i} is undefined or null`);
+      }
+
+      const transactionBuffer = Buffer.from(transaction, "hex");
+      const isLastTransaction = i === transactions.length - 1;
+
+      if (transactionBuffer.length <= MAX_APDU_DATA_LENGTH) {
+        // Small transaction - send directly
+        const p2 = isLastTransaction ? P2_MSG_END : P2_MORE | P2_MSG_END;
+
+        const response = await this.transport.send(
+          CLA,
+          INS.SIGN,
+          P1_SIGN_UNTYPED_VERSIONED_MESSAGE,
+          p2,
+          transactionBuffer,
+        );
+
+        if (isLastTransaction) {
+          this.checkTransportResponse(response);
+          const responseData = this.extractResponseData(response);
+          return this.parseSignatureResponse(responseData, challenge);
+        } else {
+          this.checkTransportResponse(response);
+        }
+      } else {
+        // Large transaction - use chunking
+        const responseData = await this.sendChunkedData({
+          ins: INS.SIGN,
+          p1: P1_SIGN_UNTYPED_VERSIONED_MESSAGE,
+          payload: transactionBuffer,
+          isFinal: isLastTransaction,
+        });
+
+        if (isLastTransaction && responseData) {
+          return this.parseSignatureResponse(responseData, challenge);
+        }
+      }
+    }
+
+    throw new TypeError("No transactions provided");
   }
 
   /**
@@ -135,7 +332,8 @@ export default class Canton {
       Buffer.alloc(0),
     );
 
-    const responseData = this.handleTransportResponse(response, "version");
+    this.checkTransportResponse(response);
+    const responseData = this.extractResponseData(response);
     const { major, minor, patch } = this.extractVersion(responseData);
 
     return {
@@ -144,47 +342,137 @@ export default class Canton {
   }
 
   /**
-   * Converts 65-byte Canton format to 64-byte Ed25519:
-   * [40][64_bytes_signature][00] (132 hex chars)
+   * Validate Uint8Array with descriptive error message
+   * @private
+   */
+  private validateUint8Array(value: unknown, context: string): void {
+    if (!value) {
+      throw new TypeError(`${context} is undefined or null`);
+    }
+    if (!(value instanceof Uint8Array)) {
+      throw new TypeError(`${context} is not a Uint8Array: ${typeof value}`);
+    }
+  }
+
+  /**
+   * Unified chunking strategy for sending data to device
    * @private
    */
-  private cleanSignatureFormat(signature: string): CantonSignature {
+  private async sendChunkedData({
+    ins,
+    p1,
+    payload,
+    isFinal = false,
+  }: {
+    ins: number;
+    p1: number;
+    payload: Buffer;
+    isFinal?: boolean;
+  }): Promise<Buffer | null> {
+    const chunks = this.createChunks(payload);
+    let responseData: Buffer | null = null;
+
+    for (let i = 0; i < chunks.length; i++) {
+      const isLastChunk = i === chunks.length - 1;
+      let p2 = P2_MORE;
+
+      if (isLastChunk) {
+        p2 = isFinal ? P2_MSG_END : P2_MORE | P2_MSG_END;
+      }
+
+      const response = await this.transport.send(CLA, ins, p1, p2, chunks[i]);
+
+      if (isFinal && isLastChunk) {
+        this.checkTransportResponse(response);
+        responseData = this.extractResponseData(response);
+      } else {
+        this.checkTransportResponse(response);
+      }
+    }
+
+    return responseData;
+  }
+
+  /**
+   * Create optimized chunks from payload
+   * @private
+   */
+  private createChunks(payload: Buffer): Buffer[] {
+    if (payload.length <= MAX_APDU_DATA_LENGTH) {
+      return [payload];
+    }
+
+    const totalChunks = Math.ceil(payload.length / MAX_APDU_DATA_LENGTH);
+    const chunks: Buffer[] = new Array(totalChunks);
+    let offset = 0;
+
+    for (let i = 0; i < totalChunks; i++) {
+      const chunkSize = Math.min(MAX_APDU_DATA_LENGTH, payload.length - offset);
+      chunks[i] = payload.slice(offset, offset + chunkSize);
+      offset += chunkSize;
+    }
+
+    return chunks;
+  }
+
+  /**
+   * Parse signature response - handles both TLV format (onboarding) and single signatures
+   * @private
+   */
+
+  private parseSignatureResponse(response: Buffer, challenge?: string): CantonSignature {
+    // Handle TLV (Type-Length-Value) format: [40][64B main][00][40][64B challenge] = 262 hex chars (131 bytes)
+    if (
+      response.length === 131 &&
+      response.readUInt8(0) === 0x40 &&
+      response.readUInt8(65) === 0x00 &&
+      response.readUInt8(66) === 0x40
+    ) {
+      const signature = response.slice(1, 65).toString("hex");
+      const applicationSignature = response.slice(67, 131).toString("hex");
+
+      return {
+        signature,
+        ...(challenge && { applicationSignature }),
+      };
+    }
+
+    // Handle single signature formats
+    const signature = response.toString("hex");
+
+    // Pure 64-byte Ed25519 signature = 128 hex chars (64 bytes)
     if (signature.length === ED25519_SIGNATURE_HEX_LENGTH) {
-      return signature;
+      return { signature };
     }
 
+    // Canton-framed signature: [40][64B Ed25519 sig][00] = 132 hex chars (65 bytes)
     if (signature.length === CANTON_SIGNATURE_HEX_LENGTH) {
       const cleanedSignature = signature.slice(2, -2);
-      return cleanedSignature;
+      return { signature: cleanedSignature };
     }
 
-    console.warn(`[Canton]: Unknown signature format (${signature.length} chars)`);
-    return signature;
+    return { signature };
   }
 
   /**
-   * Helper method to handle transport response and check for errors
+   * Check transport response for errors and throw appropriate exceptions
    * @private
    */
-  private handleTransportResponse(
-    response: Buffer,
-    errorType: "address" | "transaction" | "version",
-  ): Buffer {
+  private checkTransportResponse(response: Buffer): void {
     const statusCode = response.readUInt16BE(response.length - 2);
-    const responseData = response.slice(0, response.length - 2);
-
-    if (statusCode === STATUS.USER_CANCEL) {
-      switch (errorType) {
-        case "address":
-          throw new UserRefusedAddress();
-        case "transaction":
-          throw new UserRefusedOnDevice();
-        default:
-          throw new Error();
-      }
+
+    if (statusCode !== STATUS.OK) {
+      throw new TransportStatusError(statusCode);
     }
+  }
 
-    return responseData;
+  /**
+   * Extract response data from transport response
+   * APDU responses have format: [data][status_code(2_bytes)]
+   * @private
+   */
+  private extractResponseData(response: Buffer): Buffer {
+    return response.slice(0, -2);
   }
 
   /**
@@ -251,9 +539,9 @@ export default class Canton {
    */
   private extractVersion(data: Buffer): { major: number; minor: number; patch: number } {
     return {
-      major: parseInt(data.subarray(0, 1).toString("hex"), 16),
-      minor: parseInt(data.subarray(1, 2).toString("hex"), 16),
-      patch: parseInt(data.subarray(2, 3).toString("hex"), 16),
+      major: Number.parseInt(data.subarray(0, 1).toString("hex"), 16),
+      minor: Number.parseInt(data.subarray(1, 2).toString("hex"), 16),
+      patch: Number.parseInt(data.subarray(2, 3).toString("hex"), 16),
     };
   }
 }

package/lib/Canton.integ.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Canton.integ.test.d.ts.map

package/lib/Canton.integ.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Canton.integ.test.d.ts","sourceRoot":"","sources":["../src/Canton.integ.test.ts"],"names":[],"mappings":""}

package/lib/Canton.integ.test.js

@@ -1,88 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const hw_transport_node_speculos_http_1 = __importStar(require("@ledgerhq/hw-transport-node-speculos-http"));
-const Canton_1 = __importDefault(require("./Canton"));
-describe("AppCanton", () => {
-    let transport;
-    beforeAll(async () => {
-        transport = await hw_transport_node_speculos_http_1.default.open({});
-    });
-    afterAll(async () => {
-        transport.close();
-    });
-    describe("getAppConfiguration", () => {
-        it("returns app version", async () => {
-            // GIVEN
-            const app = new Canton_1.default(transport);
-            // WHEN
-            const result = await app.getAppConfiguration();
-            // THEN
-            expect(result).toEqual({
-                version: "2.2.2",
-            });
-        });
-    });
-    describe("getAddress", () => {
-        it("retrieves address from app", async () => {
-            // GIVEN
-            const app = new Canton_1.default(transport);
-            const derivationPath = "44'/6767'/0'/0'/0'";
-            // WHEN
-            const result = await app.getAddress(derivationPath);
-            // THEN
-            expect(result).toEqual({
-                address: "canton_1a7a97e0",
-                publicKey: "c59f7f29374d24506dd6490a5db472cf00958e195e146f3dc9c97f96d5c51097",
-            });
-        });
-    });
-    describe("signTransaction", () => {
-        it("returns sign transaction", async () => {
-            // GIVEN
-            const app = new Canton_1.default(transport);
-            const derivationPath = "44'/6767'/0'/0'/0'";
-            const txHash = "d1e98829444207b0e170346b2e80b58a2ffc602b01e190fb742016d407c84efd";
-            // WHEN
-            const signPromise = app.signTransaction(derivationPath, txHash);
-            // Waiting Speculos receive APDUs
-            const delay = (ms) => new Promise(f => setTimeout(f, ms));
-            await delay(500);
-            // Valid transaction butotn interaction sequence
-            await transport.button(hw_transport_node_speculos_http_1.SpeculosButton.BOTH);
-            await transport.button(hw_transport_node_speculos_http_1.SpeculosButton.RIGHT);
-            await transport.button(hw_transport_node_speculos_http_1.SpeculosButton.RIGHT);
-            await transport.button(hw_transport_node_speculos_http_1.SpeculosButton.RIGHT);
-            await transport.button(hw_transport_node_speculos_http_1.SpeculosButton.BOTH);
-            const result = await signPromise;
-            // THEN
-            expect(result).toEqual("40a65f53c3657bc04efefb67a425ba093a5cb5391d18142f148bb2c48daacf316114cff920a58d5996ca828c7ce265f537f1d7fca8fa82c3c73bd944a96e701a0000");
-        });
-    });
-});
-//# sourceMappingURL=Canton.integ.test.js.map

package/lib/Canton.integ.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Canton.integ.test.js","sourceRoot":"","sources":["../src/Canton.integ.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6GAAkG;AAClG,sDAA8B;AAE9B,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;IACzB,IAAI,SAAgC,CAAC;IAErC,SAAS,CAAC,KAAK,IAAI,EAAE;QACnB,SAAS,GAAG,MAAM,yCAAqB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IACH,QAAQ,CAAC,KAAK,IAAI,EAAE;QAClB,SAAS,CAAC,KAAK,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,qBAAqB,EAAE,GAAG,EAAE;QACnC,EAAE,CAAC,qBAAqB,EAAE,KAAK,IAAI,EAAE;YACnC,QAAQ;YACR,MAAM,GAAG,GAAG,IAAI,gBAAM,CAAC,SAAS,CAAC,CAAC;YAElC,OAAO;YACP,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,mBAAmB,EAAE,CAAC;YAE/C,OAAO;YACP,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;gBACrB,OAAO,EAAE,OAAO;aACjB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;QAC1B,EAAE,CAAC,4BAA4B,EAAE,KAAK,IAAI,EAAE;YAC1C,QAAQ;YACR,MAAM,GAAG,GAAG,IAAI,gBAAM,CAAC,SAAS,CAAC,CAAC;YAClC,MAAM,cAAc,GAAG,oBAAoB,CAAC;YAE5C,OAAO;YACP,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;YAEpD,OAAO;YACP,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;gBACrB,OAAO,EAAE,iBAAiB;gBAC1B,SAAS,EAAE,kEAAkE;aAC9E,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;QAC/B,EAAE,CAAC,0BAA0B,EAAE,KAAK,IAAI,EAAE;YACxC,QAAQ;YACR,MAAM,GAAG,GAAG,IAAI,gBAAM,CAAC,SAAS,CAAC,CAAC;YAClC,MAAM,cAAc,GAAG,oBAAoB,CAAC;YAC5C,MAAM,MAAM,GAAG,kEAAkE,CAAC;YAElF,OAAO;YACP,MAAM,WAAW,GAAG,GAAG,CAAC,eAAe,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;YAEhE,iCAAiC;YACjC,MAAM,KAAK,GAAG,CAAC,EAAU,EAAiB,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YACjF,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;YACjB,gDAAgD;YAChD,MAAM,SAAS,CAAC,MAAM,CAAC,gDAAc,CAAC,IAAI,CAAC,CAAC;YAC5C,MAAM,SAAS,CAAC,MAAM,CAAC,gDAAc,CAAC,KAAK,CAAC,CAAC;YAC7C,MAAM,SAAS,CAAC,MAAM,CAAC,gDAAc,CAAC,KAAK,CAAC,CAAC;YAC7C,MAAM,SAAS,CAAC,MAAM,CAAC,gDAAc,CAAC,KAAK,CAAC,CAAC;YAC7C,MAAM,SAAS,CAAC,MAAM,CAAC,gDAAc,CAAC,IAAI,CAAC,CAAC;YAE5C,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;YAEjC,OAAO;YACP,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CACpB,sIAAsI,CACvI,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/lib/Canton.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Canton.test.d.ts.map

package/lib/Canton.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Canton.test.d.ts","sourceRoot":"","sources":["../src/Canton.test.ts"],"names":[],"mappings":""}