@ledgerhq/coin-canton 0.9.0-nightly.1 → 0.9.0-nightly.20251030160608

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/coin-canton",
-  "version": "0.9.0-nightly.1",
+  "version": "0.9.0-nightly.20251030160608",
   "description": "Canton coin integration",
   "keywords": [
     "Ledger",
@@ -100,15 +100,16 @@
   "dependencies": {
     "bignumber.js": "^9.1.2",
     "invariant": "^2.2.4",
+    "protobufjs": "7.5.4",
     "rxjs": "^7.8.1",
-    "@ledgerhq/coin-framework": "^6.8.0-nightly.1",
-    "@ledgerhq/cryptoassets": "^13.31.1-nightly.0",
-    "@ledgerhq/devices": "8.6.2-nightly.0",
-    "@ledgerhq/errors": "^6.27.0-nightly.0",
-    "@ledgerhq/live-env": "^2.19.0",
-    "@ledgerhq/live-network": "^2.0.20",
+    "@ledgerhq/coin-framework": "^6.8.0-nightly.20251030160608",
+    "@ledgerhq/cryptoassets": "^13.32.0-nightly.20251030160608",
+    "@ledgerhq/devices": "8.7.0-nightly.20251030160608",
+    "@ledgerhq/errors": "^6.27.0-nightly.20251030160608",
+    "@ledgerhq/live-env": "^2.20.0-nightly.20251030160608",
+    "@ledgerhq/live-network": "^2.1.0-nightly.20251030160608",
     "@ledgerhq/logs": "^6.13.0",
-    "@ledgerhq/types-live": "^6.88.0-nightly.0"
+    "@ledgerhq/types-live": "^6.88.0-nightly.20251030160608"
   },
   "devDependencies": {
     "@types/invariant": "^2.2.37",
@@ -116,13 +117,15 @@
     "dotenv": "^16.4.5",
     "expect": "^27.4.6",
     "jest": "^29.7.0",
+    "protobufjs-cli": "1.1.2",
     "ts-jest": "^29.1.1",
     "typescript": "^5.4.5",
-    "@ledgerhq/types-cryptoassets": "^7.29.0",
-    "@ledgerhq/disable-network-setup": "^0.0.0"
+    "@ledgerhq/disable-network-setup": "^0.1.0-nightly.20251030160608",
+    "@ledgerhq/types-cryptoassets": "^7.30.0-nightly.20251030160608"
   },
   "scripts": {
     "clean": "rimraf lib lib-es",
+    "generate-proto": "node scripts/generate.js",
     "build": "tsc && tsc -m esnext --moduleResolution bundler --outDir lib-es",
     "coverage": "jest --coverage",
     "prewatch": "pnpm build",

package/scripts/generate.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+/* eslint @typescript-eslint/no-var-requires: off */
+/* eslint no-console: off */
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import https from "node:https";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const outputFile = path.join(__dirname, "../src/types/transaction-proto.json");
+const tempDir = path.join(__dirname, "temp-proto");
+
+const APP_CANTON_REPO = "LedgerHQ/app-canton";
+const APP_CANTON_BRANCH = "develop";
+const APP_CANTON_BASE_URL = `https://raw.githubusercontent.com/${APP_CANTON_REPO}/${APP_CANTON_BRANCH}`;
+
+const DAML_REPO = "digital-asset/daml";
+const DAML_BRANCH = "main";
+const DAML_BASE_URL = `https://raw.githubusercontent.com/${DAML_REPO}/${DAML_BRANCH}`;
+
+const RESERVED_WORDS = [
+  { pattern: /\bbool bool\b/g, replacement: "bool bool_" },
+  { pattern: /\bEnum enum\b/g, replacement: "Enum enum_" },
+  { pattern: /\bstring constructor = (\d+);/g, replacement: "string constructor_ = $1;" },
+];
+
+function handleFileFinish(file, resolve) {
+  file.close();
+  resolve();
+}
+
+function handleFileError(filePath, reject) {
+  return err => {
+    fs.unlink(filePath, () => {
+      /* empty function */
+    });
+    reject(err);
+  };
+}
+
+function handleHttpResponse(url, file, filePath, resolve, reject) {
+  return response => {
+    if (response.statusCode !== 200) {
+      reject(new Error(`Failed to download ${url}: ${response.statusCode}`));
+      return;
+    }
+
+    response.pipe(file);
+
+    file.on("finish", () => handleFileFinish(file, resolve));
+    file.on("error", handleFileError(filePath, reject));
+  };
+}
+
+function downloadFile(url, filePath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(filePath);
+
+    https.get(url, handleHttpResponse(url, file, filePath, resolve, reject)).on("error", err => {
+      reject(err instanceof Error ? err : new Error(err));
+    });
+  });
+}
+
+const PROTO_FILES = [
+  {
+    repoPath: "proto/device.proto",
+    localPath: "device.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath: "proto/com/daml/ledger/api/v2/value.proto",
+    localPath: "com/daml/ledger/api/v2/value.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath: "proto/com/daml/ledger/api/v2/value_cb.proto",
+    localPath: "com/daml/ledger/api/v2/value_cb.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath:
+      "sdk/canton/community/ledger-api/src/main/protobuf/com/daml/ledger/api/v2/interactive/interactive_submission_common_data.proto",
+    localPath: "com/daml/ledger/api/v2/interactive/interactive_submission_common_data.proto",
+    source: "daml",
+  },
+  {
+    repoPath:
+      "sdk/canton/community/ledger-api/src/main/protobuf/com/daml/ledger/api/v2/interactive/transaction/v1/interactive_submission_data.proto",
+    localPath:
+      "com/daml/ledger/api/v2/interactive/transaction/v1/interactive_submission_data.proto",
+    source: "daml",
+  },
+  {
+    repoPath: "proto/interactive_submission_data_cb.proto",
+    localPath:
+      "com/daml/ledger/api/v2/interactive/transaction/v1/interactive_submission_data_cb.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath: "proto/google/protobuf/any.proto",
+    localPath: "google/protobuf/any.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath: "proto/google/protobuf/duration.proto",
+    localPath: "google/protobuf/duration.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath: "proto/google/protobuf/empty.proto",
+    localPath: "google/protobuf/empty.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath: "proto/google/protobuf/timestamp.proto",
+    localPath: "google/protobuf/timestamp.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath: "proto/google/rpc/error_details.proto",
+    localPath: "google/rpc/error_details.proto",
+    source: "app-canton",
+  },
+  {
+    repoPath: "proto/google/rpc/status.proto",
+    localPath: "google/rpc/status.proto",
+    source: "app-canton",
+  },
+];
+
+function ensureDirectoryExists(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function getDownloadUrl(protoFile) {
+  const baseUrl = protoFile.source === "daml" ? DAML_BASE_URL : APP_CANTON_BASE_URL;
+  return `${baseUrl}/${protoFile.repoPath}`;
+}
+
+async function downloadProtoFile(protoFile) {
+  const url = getDownloadUrl(protoFile);
+  const localPath = path.join(tempDir, protoFile.localPath);
+
+  ensureDirectoryExists(path.dirname(localPath));
+
+  try {
+    await downloadFile(url, localPath);
+    console.log(`Downloaded: ${protoFile.localPath}`);
+  } catch (error) {
+    console.error(`Failed to download ${protoFile.localPath}:`, error.message);
+    throw error;
+  }
+}
+
+async function downloadProtoFiles() {
+  console.log("Downloading proto files from...");
+
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+  }
+
+  for (const protoFile of PROTO_FILES) {
+    await downloadProtoFile(protoFile);
+  }
+
+  console.log("All proto files downloaded successfully!");
+}
+
+// Replace reserved words to make sure only C allowed names are used
+// see https://github.com/LedgerHQ/app-canton/blob/develop/proto/proto_gen.sh#L257
+function replaceReservedWords(filePath) {
+  if (!fs.existsSync(filePath)) return;
+
+  let content = fs.readFileSync(filePath, "utf8");
+
+  for (const { pattern, replacement } of RESERVED_WORDS) {
+    content = content.replace(pattern, replacement);
+  }
+
+  fs.writeFileSync(filePath, content);
+  console.log(`Updated field names in ${path.basename(filePath)}`);
+}
+
+// Clean up temp directory
+function cleanup() {
+  if (fs.existsSync(tempDir)) {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    console.log("Cleaned up temporary files");
+  }
+}
+
+function processProtoFiles() {
+  // Replace field names in proto files
+  replaceReservedWords(path.join(tempDir, "com/daml/ledger/api/v2/value.proto"));
+  replaceReservedWords(path.join(tempDir, "com/daml/ledger/api/v2/value_cb.proto"));
+}
+
+function generateProtobufBindings() {
+  // Sanitize paths to prevent command injection
+  const sanitizedTempDir = path.resolve(tempDir);
+  const sanitizedOutputFile = path.resolve(outputFile);
+  const deviceProtoPath = path.join(sanitizedTempDir, "device.proto");
+
+  // Validate that paths exist and are within expected directories
+  if (!fs.existsSync(deviceProtoPath)) {
+    throw new Error(`Device proto file not found: ${deviceProtoPath}`);
+  }
+
+  if (!sanitizedTempDir.startsWith(path.resolve(__dirname))) {
+    throw new Error("Invalid temp directory path");
+  }
+
+  if (!sanitizedOutputFile.startsWith(path.resolve(__dirname, ".."))) {
+    throw new Error("Invalid output file path");
+  }
+
+  // Use npx from the same Node.js installation directory to avoid PATH manipulation
+  const npxPath = path.join(process.execPath, "..", "npx");
+  const absoluteNpxPath = path.resolve(npxPath);
+
+  execSync(
+    absoluteNpxPath,
+    [
+      "pbjs",
+      "-t",
+      "json",
+      "-w",
+      "es6",
+      "--path",
+      sanitizedTempDir,
+      "-o",
+      sanitizedOutputFile,
+      deviceProtoPath,
+    ],
+    {
+      stdio: "inherit",
+      cwd: __dirname,
+    },
+  );
+}
+
+try {
+  console.log("Generating protobuf bindings...");
+
+  await downloadProtoFiles();
+  processProtoFiles();
+  generateProtobufBindings();
+
+  console.log("Protobuf bindings generated successfully!");
+} catch (error) {
+  console.error("Error generating protobuf bindings:", error.message);
+  process.exit(1);
+} finally {
+  cleanup();
+}

package/src/bridge/deviceTransactionConfig.test.ts

@@ -2,21 +2,25 @@ import getDeviceTransactionConfig from "./deviceTransactionConfig";
 import BigNumber from "bignumber.js";
 
 describe("getDeviceTransactionConfig", () => {
-  it("should return amount field when it's more than 0", () => {
+  it("should return amount field when it's more than 0", async () => {
     expect(
-      getDeviceTransactionConfig({
-        transaction: {},
-        status: { amount: new BigNumber(1), estimatedFees: new BigNumber(0) },
-      } as any)[0],
+      (
+        await getDeviceTransactionConfig({
+          transaction: {},
+          status: { amount: new BigNumber(1), estimatedFees: new BigNumber(0) },
+        } as any)
+      )[0],
     ).toEqual({ type: "amount", label: "Amount" });
   });
 
-  it("should return fee field when it's more than 0", () => {
+  it("should return fee field when it's more than 0", async () => {
     expect(
-      getDeviceTransactionConfig({
-        transaction: {},
-        status: { amount: new BigNumber(0), estimatedFees: new BigNumber(1) },
-      } as any)[0],
+      (
+        await getDeviceTransactionConfig({
+          transaction: {},
+          status: { amount: new BigNumber(0), estimatedFees: new BigNumber(1) },
+        } as any)
+      )[0],
     ).toEqual({ type: "fees", label: "Fees" });
   });
 });

package/src/bridge/deviceTransactionConfig.ts

@@ -3,7 +3,7 @@ import type { Transaction, TransactionStatus } from "../types";
 import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
 
 // This method adds additional fields that need to be reviewed when signing a transaction on the device.
-function getDeviceTransactionConfig({
+async function getDeviceTransactionConfig({
   transaction: {},
   status: { amount, estimatedFees },
 }: {
@@ -11,7 +11,7 @@ function getDeviceTransactionConfig({
   parentAccount: Account | null | undefined;
   transaction: Transaction;
   status: TransactionStatus;
-}): Array<CommonDeviceTransactionField> {
+}): Promise<Array<CommonDeviceTransactionField>> {
   const fields: Array<CommonDeviceTransactionField> = [];
 
   if (!amount.isZero()) {

package/src/bridge/estimateMaxSpendable.ts

@@ -5,19 +5,17 @@ import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets/abandonseed";
 import { getTransactionStatus } from "./getTransactionStatus";
 import { prepareTransaction } from "./prepareTransaction";
 import { createTransaction } from "./createTransaction";
-import { Transaction } from "../types";
+import { Transaction, CantonAccount } from "../types";
 
-export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
-  account,
-  parentAccount,
-  transaction,
-}) => {
+export const estimateMaxSpendable: AccountBridge<
+  Transaction,
+  CantonAccount
+>["estimateMaxSpendable"] = async ({ account, parentAccount, transaction }) => {
   const mainAccount = getMainAccount(account, parentAccount);
   const newTransaction = await prepareTransaction(mainAccount, {
     ...createTransaction(account),
     ...transaction,
-    // fee estimation might require a recipient to work, in that case, we use a dummy one
-    recipient: transaction?.recipient || getAbandonSeedAddress("boilerplate"),
+    recipient: transaction?.recipient || getAbandonSeedAddress("canton_network"),
     amount: new BigNumber(0),
   });
   const status = await getTransactionStatus(mainAccount, newTransaction);