@bitgo-beta/key-card 0.0.1-beta.22 → 0.0.1-beta.2200

package/dist/src/parseKeycard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseKeycard.d.ts","sourceRoot":"","sources":["../../src/parseKeycard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAEhE,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0CF;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,CA4DrE;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,EAAE,CAyErE"}

package/dist/src/parseKeycard.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSafeKeycardBox = void 0;
+exports.buildLinesFromPDFNodes = buildLinesFromPDFNodes;
+exports.parseKeycardFromLines = parseKeycardFromLines;
+var sdk_lib_safes_1 = require("@bitgo-beta/sdk-lib-safes");
+Object.defineProperty(exports, "parseSafeKeycardBox", { enumerable: true, get: function () { return sdk_lib_safes_1.parseSafeKeycardBox; } });
+const sectionHeaderRegex = /^([A-D])\s*[:.)-]\s*(.+?)\s*$/i;
+const dataLineRegex = /^data\s*:\s*(.*)$/i;
+const faqHeaderRegex = /^BitGo\s+KeyCard\s+FAQ$/i;
+// PDF coordinate tolerance in points. Nodes within this distance on the Y-axis
+// are treated as belonging to the same line; nodes further apart are separate lines.
+const PDF_LINE_Y_TOLERANCE = 2;
+// Horizontal gap in points above which a space is inserted between adjacent nodes.
+const PDF_NODE_GAP_THRESHOLD = 2;
+function sanitizeText(input) {
+    return input.replace(/\s+/g, ' ').trim();
+}
+function normalizeSectionValue(rawValue) {
+    // Two-pass removal of "Part N" page-continuation labels:
+    // 1. Line filter: removes labels that appear as standalone lines.
+    // 2. Regex replace: removes labels embedded mid-line when
+    //    buildLinesFromPDFNodes merges them with adjacent content at the same
+    //    y-coordinate (e.g. "...X88bPart 2 lFPMd...").
+    // join('') intentionally uses no separator — section values are continuous
+    // strings (base64 / xpub) that wrap across PDF lines without spaces.
+    return rawValue
+        .split('\n')
+        .filter((line) => !/^Part\s+\d+$/i.test(line.trim()))
+        .join('')
+        .replace(/\s*Part\s+\d+\s*/gi, '')
+        .trim();
+}
+function countChar(input, char) {
+    return input.split(char).length - 1;
+}
+function isEncryptedWalletPasswordSectionTitle(title) {
+    const normalized = title.toLowerCase();
+    // Box D is titled "Encrypted Wallet Password" (wallet) or "Encrypted Safe Password" (safe).
+    return normalized.includes('encrypted wallet password') || normalized.includes('encrypted safe password');
+}
+/**
+ * Reconstructs logical text lines from an unordered set of PDF text nodes.
+ *
+ * PDF text extraction returns individual positioned fragments. This function
+ * sorts them by page then Y-coordinate (top-to-bottom), groups fragments
+ * within PDF_LINE_Y_TOLERANCE points of each other onto the same line, and
+ * inserts a space between fragments that are separated by more than
+ * PDF_NODE_GAP_THRESHOLD points horizontally.
+ */
+function buildLinesFromPDFNodes(nodes) {
+    const sortedNodes = [...nodes].sort((a, b) => {
+        if (a.page !== b.page) {
+            return a.page - b.page;
+        }
+        const yDiff = Math.abs(a.y - b.y);
+        if (yDiff > PDF_LINE_Y_TOLERANCE) {
+            return b.y - a.y;
+        }
+        return a.x - b.x;
+    });
+    const lines = [];
+    let currentLineNodes = [];
+    let currentPage = -1;
+    let currentY = Number.NaN;
+    function flushLine() {
+        if (currentLineNodes.length === 0) {
+            return;
+        }
+        const sortedLineNodes = [...currentLineNodes].sort((a, b) => a.x - b.x);
+        let line = '';
+        let previousRightEdge = null;
+        for (const node of sortedLineNodes) {
+            const piece = sanitizeText(node.text);
+            if (!piece) {
+                continue;
+            }
+            if (previousRightEdge !== null && node.x - previousRightEdge > PDF_NODE_GAP_THRESHOLD) {
+                line += ' ';
+            }
+            line += piece;
+            previousRightEdge = node.x + node.width;
+        }
+        const normalizedLine = line.trim();
+        if (normalizedLine) {
+            lines.push(normalizedLine);
+        }
+    }
+    for (const node of sortedNodes) {
+        const pageChanged = node.page !== currentPage;
+        const lineChanged = Number.isNaN(currentY) || Math.abs(node.y - currentY) > PDF_LINE_Y_TOLERANCE;
+        if (pageChanged || lineChanged) {
+            flushLine();
+            currentLineNodes = [node];
+            currentPage = node.page;
+            currentY = node.y;
+            continue;
+        }
+        currentLineNodes.push(node);
+    }
+    flushLine();
+    return lines;
+}
+function parseKeycardFromLines(lines) {
+    const sections = [];
+    let currentSectionIndex = -1;
+    for (const line of lines) {
+        const labelMatch = line.match(sectionHeaderRegex);
+        if (labelMatch) {
+            const section = labelMatch[1]?.toUpperCase();
+            const title = sanitizeText(labelMatch[2] ?? '');
+            if (section && title) {
+                sections.push({
+                    section,
+                    title,
+                    values: [],
+                    isCapturingData: false,
+                    openCurlyCount: 0,
+                });
+                currentSectionIndex = sections.length - 1;
+                continue;
+            }
+        }
+        if (currentSectionIndex < 0) {
+            continue;
+        }
+        const currentSection = sections[currentSectionIndex];
+        if (!currentSection) {
+            continue;
+        }
+        const dataLineMatch = line.match(dataLineRegex);
+        if (dataLineMatch) {
+            currentSection.isCapturingData = true;
+            const inlineValue = sanitizeText(dataLineMatch[1] ?? '');
+            if (inlineValue) {
+                currentSection.values.push(inlineValue);
+                currentSection.openCurlyCount += countChar(inlineValue, '{') - countChar(inlineValue, '}');
+            }
+            continue;
+        }
+        if (currentSection.isCapturingData) {
+            if (faqHeaderRegex.test(line)) {
+                currentSection.isCapturingData = false;
+                continue;
+            }
+            currentSection.values.push(line);
+            // For encrypted wallet password, data is a single JSON object. Stop as
+            // soon as the object closes so footer/FAQ content is not appended.
+            if (isEncryptedWalletPasswordSectionTitle(currentSection.title)) {
+                currentSection.openCurlyCount += countChar(line, '{') - countChar(line, '}');
+                if (currentSection.values.length > 0 && currentSection.openCurlyCount <= 0) {
+                    currentSection.isCapturingData = false;
+                }
+            }
+        }
+    }
+    return sections
+        .filter(({ section, values }) => ['A', 'B', 'C', 'D'].includes(section) && values.length > 0)
+        .map(({ section, title, values }) => ({
+        label: `${section}: ${title}`,
+        value: normalizeSectionValue(values.join('\n')),
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parseKeycard.js","sourceRoot":"","sources":["../../src/parseKeycard.ts"],"names":[],"mappings":"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","sourcesContent":["export { parseSafeKeycardBox } from '@bitgo-beta/sdk-lib-safes';\n\nexport type PDFTextNode = {\n  text: string;\n  x: number;\n  y: number;\n  page: number;\n  width: number;\n};\n\nexport type KeycardEntry = {\n  label: string;\n  value: string;\n};\n\nconst sectionHeaderRegex = /^([A-D])\\s*[:.)-]\\s*(.+?)\\s*$/i;\nconst dataLineRegex = /^data\\s*:\\s*(.*)$/i;\nconst faqHeaderRegex = /^BitGo\\s+KeyCard\\s+FAQ$/i;\n\n// PDF coordinate tolerance in points. Nodes within this distance on the Y-axis\n// are treated as belonging to the same line; nodes further apart are separate lines.\nconst PDF_LINE_Y_TOLERANCE = 2;\n// Horizontal gap in points above which a space is inserted between adjacent nodes.\nconst PDF_NODE_GAP_THRESHOLD = 2;\n\nfunction sanitizeText(input: string): string {\n  return input.replace(/\\s+/g, ' ').trim();\n}\n\nfunction normalizeSectionValue(rawValue: string): string {\n  // Two-pass removal of \"Part N\" page-continuation labels:\n  // 1. Line filter: removes labels that appear as standalone lines.\n  // 2. Regex replace: removes labels embedded mid-line when\n  //    buildLinesFromPDFNodes merges them with adjacent content at the same\n  //    y-coordinate (e.g. \"...X88bPart 2 lFPMd...\").\n  // join('') intentionally uses no separator — section values are continuous\n  // strings (base64 / xpub) that wrap across PDF lines without spaces.\n  return rawValue\n    .split('\\n')\n    .filter((line) => !/^Part\\s+\\d+$/i.test(line.trim()))\n    .join('')\n    .replace(/\\s*Part\\s+\\d+\\s*/gi, '')\n    .trim();\n}\n\nfunction countChar(input: string, char: string): number {\n  return input.split(char).length - 1;\n}\n\nfunction isEncryptedWalletPasswordSectionTitle(title: string): boolean {\n  const normalized = title.toLowerCase();\n  // Box D is titled \"Encrypted Wallet Password\" (wallet) or \"Encrypted Safe Password\" (safe).\n  return normalized.includes('encrypted wallet password') || normalized.includes('encrypted safe password');\n}\n\n/**\n * Reconstructs logical text lines from an unordered set of PDF text nodes.\n *\n * PDF text extraction returns individual positioned fragments. This function\n * sorts them by page then Y-coordinate (top-to-bottom), groups fragments\n * within PDF_LINE_Y_TOLERANCE points of each other onto the same line, and\n * inserts a space between fragments that are separated by more than\n * PDF_NODE_GAP_THRESHOLD points horizontally.\n */\nexport function buildLinesFromPDFNodes(nodes: PDFTextNode[]): string[] {\n  const sortedNodes = [...nodes].sort((a, b) => {\n    if (a.page !== b.page) {\n      return a.page - b.page;\n    }\n    const yDiff = Math.abs(a.y - b.y);\n    if (yDiff > PDF_LINE_Y_TOLERANCE) {\n      return b.y - a.y;\n    }\n    return a.x - b.x;\n  });\n\n  const lines: string[] = [];\n  let currentLineNodes: PDFTextNode[] = [];\n  let currentPage = -1;\n  let currentY = Number.NaN;\n\n  function flushLine() {\n    if (currentLineNodes.length === 0) {\n      return;\n    }\n\n    const sortedLineNodes = [...currentLineNodes].sort((a, b) => a.x - b.x);\n    let line = '';\n    let previousRightEdge: number | null = null;\n    for (const node of sortedLineNodes) {\n      const piece = sanitizeText(node.text);\n      if (!piece) {\n        continue;\n      }\n\n      if (previousRightEdge !== null && node.x - previousRightEdge > PDF_NODE_GAP_THRESHOLD) {\n        line += ' ';\n      }\n      line += piece;\n      previousRightEdge = node.x + node.width;\n    }\n\n    const normalizedLine = line.trim();\n    if (normalizedLine) {\n      lines.push(normalizedLine);\n    }\n  }\n\n  for (const node of sortedNodes) {\n    const pageChanged = node.page !== currentPage;\n    const lineChanged = Number.isNaN(currentY) || Math.abs(node.y - currentY) > PDF_LINE_Y_TOLERANCE;\n    if (pageChanged || lineChanged) {\n      flushLine();\n      currentLineNodes = [node];\n      currentPage = node.page;\n      currentY = node.y;\n      continue;\n    }\n\n    currentLineNodes.push(node);\n  }\n\n  flushLine();\n  return lines;\n}\n\nexport function parseKeycardFromLines(lines: string[]): KeycardEntry[] {\n  const sections: Array<{\n    section: string;\n    title: string;\n    values: string[];\n    isCapturingData: boolean;\n    openCurlyCount: number;\n  }> = [];\n  let currentSectionIndex = -1;\n\n  for (const line of lines) {\n    const labelMatch = line.match(sectionHeaderRegex);\n    if (labelMatch) {\n      const section = labelMatch[1]?.toUpperCase();\n      const title = sanitizeText(labelMatch[2] ?? '');\n      if (section && title) {\n        sections.push({\n          section,\n          title,\n          values: [],\n          isCapturingData: false,\n          openCurlyCount: 0,\n        });\n        currentSectionIndex = sections.length - 1;\n        continue;\n      }\n    }\n\n    if (currentSectionIndex < 0) {\n      continue;\n    }\n\n    const currentSection = sections[currentSectionIndex];\n    if (!currentSection) {\n      continue;\n    }\n\n    const dataLineMatch = line.match(dataLineRegex);\n    if (dataLineMatch) {\n      currentSection.isCapturingData = true;\n      const inlineValue = sanitizeText(dataLineMatch[1] ?? '');\n      if (inlineValue) {\n        currentSection.values.push(inlineValue);\n        currentSection.openCurlyCount += countChar(inlineValue, '{') - countChar(inlineValue, '}');\n      }\n      continue;\n    }\n\n    if (currentSection.isCapturingData) {\n      if (faqHeaderRegex.test(line)) {\n        currentSection.isCapturingData = false;\n        continue;\n      }\n\n      currentSection.values.push(line);\n\n      // For encrypted wallet password, data is a single JSON object. Stop as\n      // soon as the object closes so footer/FAQ content is not appended.\n      if (isEncryptedWalletPasswordSectionTitle(currentSection.title)) {\n        currentSection.openCurlyCount += countChar(line, '{') - countChar(line, '}');\n        if (currentSection.values.length > 0 && currentSection.openCurlyCount <= 0) {\n          currentSection.isCapturingData = false;\n        }\n      }\n    }\n  }\n\n  return sections\n    .filter(({ section, values }) => ['A', 'B', 'C', 'D'].includes(section) && values.length > 0)\n    .map(({ section, title, values }) => ({\n      label: `${section}: ${title}`,\n      value: normalizeSectionValue(values.join('\\n')),\n    }));\n}\n"]}

package/dist/src/types.d.ts

@@ -0,0 +1,81 @@
+import { EncryptionVersion, Keychain, KeychainsTriplet } from '@bitgo-beta/sdk-core';
+import { BaseCoin, KeyCurve } from '@bitgo-beta/statics';
+import type { SafeKeycardRoots, SafeRootKeyType } from '@bitgo-beta/sdk-lib-safes';
+export type { SafeKeycardRoots, SafeRootKeyType };
+export interface GenerateQrDataBaseParams {
+    activationCode?: string;
+    keyCardImage?: HTMLImageElement;
+    walletLabel: string;
+}
+export interface GenerateQrDataForKeychainParams {
+    bitgoKeychain: Keychain;
+    curve: KeyCurve;
+}
+export interface GenerateQrDataCoinParams {
+    coin: Readonly<BaseCoin>;
+    passcodeEncryptionCode?: string;
+    passphrase?: string;
+    /** @deprecated Ignored because Box D uses a high-entropy key. */
+    encryptionVersion?: EncryptionVersion;
+}
+export interface GenerateQrDataParams extends GenerateQrDataCoinParams {
+    backupKeychain: Keychain;
+    backupKeyProvider?: string;
+    backupMasterKey?: string;
+    /**
+     * @description The key used to derive the backup key using {@link backupMasterKey} as the seed.
+     */
+    backupMasterPublicKey?: string;
+    bitgoKeychain: Keychain;
+    userKeychain: Keychain;
+    userMasterKey?: string;
+    /**
+     * @description The key used to derive the user key using {@link userMasterKey} as the seed.
+     */
+    userMasterPublicKey?: string;
+}
+export interface GenerateLightningQrDataParams extends GenerateQrDataCoinParams {
+    userAuthKeychain: Keychain;
+}
+/**
+ * Fixed render/scan order of the four roots on the safe keycard. Kept stable so a
+ * generated keycard and a re-scanned one line up slot-for-slot.
+ */
+export declare const SAFE_ROOT_ORDER: SafeRootKeyType[];
+/** The product a keycard belongs to, used for user-facing wording (e.g. Box D copy). */
+export type KeycardEntity = 'wallet' | 'safe';
+export interface GenerateSafeQrDataParams extends GenerateQrDataCoinParams {
+    roots: Record<SafeRootKeyType, KeychainsTriplet>;
+}
+export type GenerateKeycardParams = GenerateQrDataBaseParams & (GenerateQrDataForKeychainParams | GenerateQrDataParams | GenerateLightningQrDataParams);
+export interface IDrawKeyCard {
+    activationCode?: string;
+    keyCardImage?: HTMLImageElement;
+    qrData: QrData;
+    questions: FAQ[];
+    walletLabel?: string;
+    curve?: KeyCurve;
+    pageBreakBeforeIndices?: number[];
+    useQrPartHeaders?: boolean;
+}
+export interface FAQ {
+    question: string;
+    answer: string[];
+}
+export interface QrDataEntry {
+    data: string;
+    description: string;
+    title: string;
+    publicMasterKey?: string;
+}
+export type MasterPublicKeyQrDataEntry = Omit<QrDataEntry, 'publicMasterKey'>;
+export interface QrData {
+    backup?: QrDataEntry;
+    backupMasterPublicKey?: MasterPublicKeyQrDataEntry;
+    bitgo?: QrDataEntry;
+    passcode?: QrDataEntry;
+    curve?: KeyCurve;
+    user: QrDataEntry;
+    userMasterPublicKey?: MasterPublicKeyQrDataEntry;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/src/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAFE_ROOT_ORDER = void 0;
+const slotsInRenderOrder = {
+    secp256k1Multisig: true,
+    ecdsaMpc: true,
+    eddsaMpc: true,
+    ed25519Multisig: true,
+};
+/**
+ * Fixed render/scan order of the four roots on the safe keycard. Kept stable so a
+ * generated keycard and a re-scanned one line up slot-for-slot.
+ */
+exports.SAFE_ROOT_ORDER = Object.keys(slotsInRenderOrder);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/upgradeWalletEncryption.d.ts

@@ -0,0 +1,27 @@
+/**
+ * PDF-generation helpers for the wallet encryption upgrade flow.
+ *
+ * Orchestration (unlocking the session, re-encrypting keychains, PUT-ing to the server) lives on
+ * `Wallet.upgradeEncryption` in `@bitgo-beta/sdk-core`. This module contains only the pieces that
+ * depend on `jspdf`/`qrcode` — a factory that returns a `UpgradeEncryptionPdfGenerator` the
+ * caller can pass into that method, plus a Node-side coin-logo loader.
+ */
+import * as https from 'https';
+import { UpgradeEncryptionPdfGenerator } from '@bitgo-beta/sdk-core';
+/**
+ * Fetch a coin logo image and return an HTMLImageElement-compatible object.
+ * jsPDF reads `.src` in Node.js; computeKeyCardImageDimensions reads `.width`/`.height`.
+ * Returns undefined on any failure — the keycard is generated without the logo in that case.
+ */
+export declare function loadKeycardImage(url: string, httpGet?: typeof https.get): Promise<HTMLImageElement | undefined>;
+export interface KeycardPdfGeneratorOptions {
+    /** Base URL for loading the coin logo (e.g. Environments[env].uri). Omit to skip the logo. */
+    imageBaseUrl?: string;
+}
+/**
+ * Build a {@link UpgradeEncryptionPdfGenerator} that regenerates the keycard PDF with the
+ * canonical `generateQrData` + `drawKeycard` flow. Pass the returned function into
+ * `Wallet.upgradeEncryption({ generatePdf })`.
+ */
+export declare function createKeycardPdfGenerator(options?: KeycardPdfGeneratorOptions): UpgradeEncryptionPdfGenerator;
+//# sourceMappingURL=upgradeWalletEncryption.d.ts.map

package/dist/src/upgradeWalletEncryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradeWalletEncryption.d.ts","sourceRoot":"","sources":["../../src/upgradeWalletEncryption.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAKrE;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,OAAO,KAAK,CAAC,GAAe,GACpC,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAyBvC;AAED,MAAM,WAAW,0BAA0B;IACzC,8FAA8F;IAC9F,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,0BAA+B,GAAG,6BAA6B,CA0BjH"}

package/dist/src/upgradeWalletEncryption.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * PDF-generation helpers for the wallet encryption upgrade flow.
+ *
+ * Orchestration (unlocking the session, re-encrypting keychains, PUT-ing to the server) lives on
+ * `Wallet.upgradeEncryption` in `@bitgo-beta/sdk-core`. This module contains only the pieces that
+ * depend on `jspdf`/`qrcode` — a factory that returns a `UpgradeEncryptionPdfGenerator` the
+ * caller can pass into that method, plus a Node-side coin-logo loader.
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadKeycardImage = loadKeycardImage;
+exports.createKeycardPdfGenerator = createKeycardPdfGenerator;
+const https = __importStar(require("https"));
+const statics_1 = require("@bitgo-beta/statics");
+const generateQrData_1 = require("./generateQrData");
+const faq_1 = require("./faq");
+const drawKeycard_1 = require("./drawKeycard");
+/**
+ * Fetch a coin logo image and return an HTMLImageElement-compatible object.
+ * jsPDF reads `.src` in Node.js; computeKeyCardImageDimensions reads `.width`/`.height`.
+ * Returns undefined on any failure — the keycard is generated without the logo in that case.
+ */
+async function loadKeycardImage(url, httpGet = https.get) {
+    return new Promise((resolve) => {
+        httpGet(url, (res) => {
+            if (res.statusCode !== 200) {
+                console.warn(`Warning: coin logo not loaded (HTTP ${res.statusCode}) — keycard will be generated without it`);
+                resolve(undefined);
+                return;
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                const contentType = res.headers['content-type'] ?? 'image/png';
+                const dataUrl = `data:${contentType};base64,${Buffer.concat(chunks).toString('base64')}`;
+                const img = { src: dataUrl, width: 303, height: 40 };
+                resolve(img);
+            });
+            res.on('error', (err) => {
+                console.warn(`Warning: coin logo not loaded (${err.message}) — keycard will be generated without it`);
+                resolve(undefined);
+            });
+        }).on('error', (err) => {
+            console.warn(`Warning: coin logo not loaded (${err.message}) — keycard will be generated without it`);
+            resolve(undefined);
+        });
+    });
+}
+/**
+ * Build a {@link UpgradeEncryptionPdfGenerator} that regenerates the keycard PDF with the
+ * canonical `generateQrData` + `drawKeycard` flow. Pass the returned function into
+ * `Wallet.upgradeEncryption({ generatePdf })`.
+ */
+function createKeycardPdfGenerator(options = {}) {
+    const { imageBaseUrl } = options;
+    return async ({ coinName, userKeychain, backupKeychain, bitgoKeychain, passphrase, passcodeEncryptionCode, walletLabel, }) => {
+        const staticsCoin = statics_1.coins.get(coinName);
+        const keyCardImage = imageBaseUrl
+            ? await loadKeycardImage(`${imageBaseUrl}/web/assets/keycards/${staticsCoin.family.toLowerCase()}.png`)
+            : undefined;
+        const qrData = await (0, generateQrData_1.generateQrData)({
+            coin: staticsCoin,
+            userKeychain,
+            backupKeychain,
+            bitgoKeychain,
+            passphrase,
+            passcodeEncryptionCode,
+        });
+        const questions = (0, faq_1.generateFaq)(staticsCoin.fullName);
+        return (0, drawKeycard_1.drawKeycard)({ qrData, questions, walletLabel, keyCardImage });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function splitKeys(key: string, limit: number): string[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAc9D"}

package/dist/src/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitKeys = splitKeys;
+function splitKeys(key, limit) {
+    if (key.length <= limit) {
+        return [key];
+    }
+    const keys = [];
+    let rightIndex = limit;
+    for (let i = 0; i < key.length; i += limit) {
+        keys.push(key.substring(i, rightIndex));
+        rightIndex = Math.min(rightIndex + limit, key.length);
+    }
+    return keys;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSw4QkFjQztBQWRELFNBQWdCLFNBQVMsQ0FBQyxHQUFXLEVBQUUsS0FBYTtJQUNsRCxJQUFJLEdBQUcsQ0FBQyxNQUFNLElBQUksS0FBSyxFQUFFLENBQUM7UUFDeEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2YsQ0FBQztJQUVELE1BQU0sSUFBSSxHQUFhLEVBQUUsQ0FBQztJQUUxQixJQUFJLFVBQVUsR0FBRyxLQUFLLENBQUM7SUFDdkIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFJLEtBQUssRUFBRSxDQUFDO1FBQzNDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQztRQUN4QyxVQUFVLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxVQUFVLEdBQUcsS0FBSyxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIHNwbGl0S2V5cyhrZXk6IHN0cmluZywgbGltaXQ6IG51bWJlcik6IHN0cmluZ1tdIHtcbiAgaWYgKGtleS5sZW5ndGggPD0gbGltaXQpIHtcbiAgICByZXR1cm4gW2tleV07XG4gIH1cblxuICBjb25zdCBrZXlzOiBzdHJpbmdbXSA9IFtdO1xuXG4gIGxldCByaWdodEluZGV4ID0gbGltaXQ7XG4gIGZvciAobGV0IGkgPSAwOyBpIDwga2V5Lmxlbmd0aDsgaSArPSBsaW1pdCkge1xuICAgIGtleXMucHVzaChrZXkuc3Vic3RyaW5nKGksIHJpZ2h0SW5kZXgpKTtcbiAgICByaWdodEluZGV4ID0gTWF0aC5taW4ocmlnaHRJbmRleCArIGxpbWl0LCBrZXkubGVuZ3RoKTtcbiAgfVxuXG4gIHJldHVybiBrZXlzO1xufVxuIl19