@onekeyfe/hd-core 1.2.0-alpha.66 → 1.2.0-alpha.67

package/src/protocols/protocol-v2/resources.ts

@@ -1,390 +0,0 @@
-import { sha256 } from '@noble/hashes/sha256';
-import { PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE } from '@onekeyfe/hd-transport';
-
-import type {
-  IProtocolV2BootResources,
-  IProtocolV2Resource,
-  IProtocolV2ResourceFile,
-  IProtocolV2ResourceType,
-  IProtocolV2Resources,
-} from '../../types';
-import type { DeviceCommands } from '../../device/DeviceCommands';
-
-export const PROTOCOL_V2_RESOURCE_TYPES = [
-  'images',
-  'animation',
-  'wallpaper',
-  'translations',
-  'roobert',
-  'noto',
-] as const satisfies readonly IProtocolV2ResourceType[];
-
-export const PROTOCOL_V2_RESOURCE_DEVICE_PATHS: Readonly<Record<IProtocolV2ResourceType, string>> =
-  {
-    images: 'vol0:/bundles/images/images.okpkg',
-    animation: 'vol0:/bundles/images/animation.okpkg',
-    wallpaper: 'vol0:/bundles/images/wallpaper.okpkg',
-    translations: 'vol0:/bundles/translations/translations.okpkg',
-    roobert: 'vol0:/bundles/font/roobert.okpkg',
-    noto: 'vol0:/bundles/font/noto.okpkg',
-  };
-
-const RESOURCE_TYPE_SET = new Set<string>(PROTOCOL_V2_RESOURCE_TYPES);
-const SHA256_HEX_LENGTH = 64;
-const SHA3_512_HEX_LENGTH = 128;
-const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
-const PROTOCOL_V2_OKPP_TYPE_OFFSET = 0x08;
-const PROTOCOL_V2_OKPP_HEADER_LENGTH_OFFSET = 0x0c;
-const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
-const PROTOCOL_V2_OKPP_HASH_SIZE = 64;
-const PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE =
-  PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE;
-const PROTOCOL_V2_MIN_FILE_READ_CHUNK_SIZE = 64;
-export const PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS = 5 * 1000;
-
-export type ProtocolV2ResourceInventoryItem = {
-  type: IProtocolV2ResourceType;
-  size: number;
-  headerHash: string;
-};
-
-export type ProtocolV2ResourceUpdateMode = 'application' | 'bootloader-recovery';
-
-export type ProtocolV2ResourceUpdatePlan = {
-  status: 'valid' | 'outdated' | 'unknown';
-  resources: IProtocolV2Resource[];
-};
-
-function toFiniteNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string') {
-    const numeric = Number(value);
-    return Number.isFinite(numeric) ? numeric : undefined;
-  }
-  if (value && typeof value === 'object') {
-    const longLike = value as { toNumber?: () => number };
-    if (typeof longLike.toNumber === 'function') {
-      const numeric = longLike.toNumber();
-      return Number.isFinite(numeric) ? numeric : undefined;
-    }
-  }
-  return undefined;
-}
-
-function toUint8Array(value: unknown): Uint8Array {
-  if (value instanceof Uint8Array) return value;
-  if (value instanceof ArrayBuffer) return new Uint8Array(value);
-  if (ArrayBuffer.isView(value)) {
-    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  }
-  if (typeof value === 'string') {
-    const hex = value.replace(/^0x/i, '');
-    if (!hex || hex.length % 2 !== 0 || /[^0-9a-f]/i.test(hex)) {
-      return new Uint8Array(0);
-    }
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let index = 0; index < bytes.length; index += 1) {
-      bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
-    }
-    return bytes;
-  }
-  return new Uint8Array(0);
-}
-
-function readAscii(bytes: Uint8Array, offset: number, length: number): string {
-  return Array.from(bytes.slice(offset, offset + length), byte => String.fromCharCode(byte)).join(
-    ''
-  );
-}
-
-function parseProtocolV2ResourceHeaderHash(bytes: Uint8Array): string | undefined {
-  if (bytes.byteLength < PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE) return undefined;
-  if (readAscii(bytes, 0, 4) !== 'OKPP') return undefined;
-  if (readAscii(bytes, PROTOCOL_V2_OKPP_TYPE_OFFSET, 4) !== 'RESC') return undefined;
-
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  if (
-    view.getUint32(PROTOCOL_V2_OKPP_HEADER_LENGTH_OFFSET, true) !== PROTOCOL_V2_OKPP_HEADER_SIZE
-  ) {
-    return undefined;
-  }
-  return bytesToHex(
-    bytes.slice(
-      PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET,
-      PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE
-    )
-  );
-}
-
-async function readProtocolV2ResourceIdentity({
-  commands,
-  resource,
-  chunkSize,
-  timeoutMs = PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS,
-}: {
-  commands: Pick<DeviceCommands, 'typedCall'>;
-  resource: IProtocolV2Resource;
-  chunkSize: number;
-  timeoutMs?: number;
-}): Promise<ProtocolV2ResourceInventoryItem | undefined> {
-  const path = PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type];
-  const pathInfo = await commands.typedCall(
-    'FilesystemPathInfoQuery',
-    'FilesystemPathInfo',
-    { path },
-    { timeoutMs }
-  );
-  const size = toFiniteNumber(pathInfo.message?.size);
-  if (
-    !pathInfo.message?.exist ||
-    pathInfo.message?.directory ||
-    !Number.isSafeInteger(size) ||
-    size !== resource.size ||
-    size < PROTOCOL_V2_OKPP_HEADER_SIZE
-  ) {
-    return undefined;
-  }
-
-  const header = new Uint8Array(PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE);
-  let offset = 0;
-  while (offset < header.byteLength) {
-    const readLength = Math.min(chunkSize, header.byteLength - offset);
-    const response = await commands.typedCall(
-      'FilesystemFileRead',
-      'FilesystemFile',
-      {
-        file: { path, offset, total_size: 0 },
-        chunk_len: readLength,
-      },
-      { timeoutMs }
-    );
-    const data = toUint8Array(response.message?.data);
-    if (data.byteLength === 0) return undefined;
-    const copied = Math.min(data.byteLength, header.byteLength - offset);
-    header.set(data.subarray(0, copied), offset);
-    offset += copied;
-  }
-
-  const headerHash = parseProtocolV2ResourceHeaderHash(header);
-  return headerHash ? { type: resource.type, size, headerHash } : undefined;
-}
-
-/**
- * 使用已发布 Pro2 固件支持的文件系统消息构建资源清单。
- * 缺失、无法读取或格式错误的文件不会进入清单，因此会被选中重写。
- */
-export async function readProtocolV2ResourceInventory({
-  commands,
-  resources,
-  chunkSize = PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
-  timeoutMs = PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS,
-}: {
-  commands: Pick<DeviceCommands, 'typedCall'>;
-  resources: readonly IProtocolV2Resource[];
-  chunkSize?: number;
-  timeoutMs?: number;
-}): Promise<ProtocolV2ResourceInventoryItem[]> {
-  const normalizedChunkSize = Number.isFinite(chunkSize)
-    ? Math.max(Math.floor(chunkSize), PROTOCOL_V2_MIN_FILE_READ_CHUNK_SIZE)
-    : PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
-  const inventory: ProtocolV2ResourceInventoryItem[] = [];
-  for (const resource of resources) {
-    try {
-      const item = await readProtocolV2ResourceIdentity({
-        commands,
-        resource,
-        chunkSize: normalizedChunkSize,
-        timeoutMs,
-      });
-      if (item) inventory.push(item);
-    } catch {
-      // 单个资源无法读取时按缺失处理，不阻断其余资源的增量检查。
-    }
-  }
-  return inventory;
-}
-
-function normalizeHex(value: unknown, expectedLength: number, field: string): string {
-  if (typeof value !== 'string') {
-    throw new Error(`Invalid Pro2 resource ${field}: expected a hexadecimal string`);
-  }
-  const normalized = value.replace(/^0x/i, '').toLowerCase();
-  if (normalized.length !== expectedLength || !/^[0-9a-f]+$/.test(normalized)) {
-    throw new Error(
-      `Invalid Pro2 resource ${field}: expected ${expectedLength} hexadecimal characters`
-    );
-  }
-  return normalized;
-}
-
-function validateResource(value: unknown, index: number): IProtocolV2Resource {
-  if (!value || typeof value !== 'object') {
-    throw new Error(`Invalid Pro2 resource at stable[${index}]`);
-  }
-  const resource = value as Partial<IProtocolV2Resource>;
-  if (typeof resource.type !== 'string' || !RESOURCE_TYPE_SET.has(resource.type)) {
-    throw new Error(`Invalid Pro2 resource type at stable[${index}]`);
-  }
-  if (typeof resource.url !== 'string' || !resource.url.startsWith('https://')) {
-    throw new Error(`Invalid Pro2 resource url at stable[${index}]`);
-  }
-  if (!Number.isSafeInteger(resource.size) || Number(resource.size) <= 0) {
-    throw new Error(`Invalid Pro2 resource size at stable[${index}]`);
-  }
-  return {
-    type: resource.type,
-    url: resource.url,
-    size: Number(resource.size),
-    fileHash: normalizeHex(resource.fileHash, SHA256_HEX_LENGTH, 'fileHash'),
-    headerHash: normalizeHex(resource.headerHash, SHA3_512_HEX_LENGTH, 'headerHash'),
-  };
-}
-
-function validateBootResources(value: unknown): IProtocolV2BootResources {
-  if (!value || typeof value !== 'object') {
-    throw new Error('Invalid Pro2 boot resources config');
-  }
-  const resource = value as Partial<IProtocolV2BootResources>;
-  if (resource.required !== false) {
-    throw new Error('Invalid Pro2 boot resources required flag: expected false');
-  }
-  if (resource.target !== 'RES') {
-    throw new Error('Invalid Pro2 boot resources target: expected RES');
-  }
-  if (
-    resource.manifestUrl !== undefined &&
-    (typeof resource.manifestUrl !== 'string' || !resource.manifestUrl.startsWith('https://'))
-  ) {
-    throw new Error('Invalid Pro2 boot resources manifestUrl');
-  }
-  if (!Array.isArray(resource.files) || resource.files.length === 0) {
-    throw new Error('Invalid Pro2 boot resources files');
-  }
-  const files = resource.files.map((value, index): IProtocolV2ResourceFile => {
-    if (!value || typeof value !== 'object') {
-      throw new Error(`Invalid Pro2 boot resource file at files[${index}]`);
-    }
-    const file = value as Partial<IProtocolV2ResourceFile>;
-    if (typeof file.url !== 'string' || !file.url.startsWith('https://')) {
-      throw new Error(`Invalid Pro2 boot resource url at files[${index}]`);
-    }
-    if (
-      typeof file.devicePath !== 'string' ||
-      !file.devicePath.startsWith('vol0:/') ||
-      file.devicePath.includes('..') ||
-      file.devicePath.includes('\\')
-    ) {
-      throw new Error(`Invalid Pro2 boot resource devicePath at files[${index}]`);
-    }
-    if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
-      throw new Error(`Invalid Pro2 boot resource size at files[${index}]`);
-    }
-    return {
-      ...(typeof file.name === 'string' && file.name ? { name: file.name } : undefined),
-      url: file.url,
-      devicePath: file.devicePath,
-      size: Number(file.size),
-      fileHash: normalizeHex(file.fileHash, SHA256_HEX_LENGTH, `boot files[${index}].fileHash`),
-    };
-  });
-  if (new Set(files.map(file => file.devicePath)).size !== files.length) {
-    throw new Error('Invalid Pro2 boot resources files: duplicate devicePath');
-  }
-  return {
-    required: false,
-    target: 'RES',
-    ...(resource.manifestUrl ? { manifestUrl: resource.manifestUrl } : undefined),
-    files,
-  };
-}
-
-/** Validate a complete Pro2 stable resource set from remote configuration. */
-export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources | undefined {
-  if (value === undefined) return undefined;
-  if (
-    !value ||
-    typeof value !== 'object' ||
-    !Array.isArray((value as { stable?: unknown }).stable)
-  ) {
-    throw new Error('Invalid Pro2 resources config: stable must be an array');
-  }
-
-  const config = value as { stable: unknown[]; boot?: unknown };
-  const stable = config.stable.map(validateResource);
-  const types = new Set(stable.map(resource => resource.type));
-  if (stable.length !== PROTOCOL_V2_RESOURCE_TYPES.length || types.size !== stable.length) {
-    throw new Error('Invalid Pro2 resources config: stable must contain six unique resource types');
-  }
-  for (const type of PROTOCOL_V2_RESOURCE_TYPES) {
-    if (!types.has(type)) {
-      throw new Error(`Invalid Pro2 resources config: stable is missing ${type}`);
-    }
-  }
-  const boot = config.boot === undefined ? undefined : validateBootResources(config.boot);
-  return {
-    stable: PROTOCOL_V2_RESOURCE_TYPES.map(type => {
-      const resource = stable.find(item => item.type === type);
-      if (!resource) {
-        throw new Error(`Invalid Pro2 resources config: stable is missing ${type}`);
-      }
-      return resource;
-    }),
-    ...(boot ? { boot } : undefined),
-  };
-}
-
-/** 比较文件系统资源清单；恢复模式无法取得清单时回退到全量更新。 */
-export function buildProtocolV2ResourceUpdatePlan({
-  resources,
-  inventory,
-  mode,
-  forced = false,
-}: {
-  resources: readonly IProtocolV2Resource[];
-  inventory?: readonly ProtocolV2ResourceInventoryItem[];
-  mode: ProtocolV2ResourceUpdateMode;
-  forced?: boolean;
-}): ProtocolV2ResourceUpdatePlan {
-  if (forced) {
-    return {
-      status: resources.length > 0 ? 'outdated' : 'valid',
-      resources: [...resources],
-    };
-  }
-  if (!inventory) {
-    return mode === 'bootloader-recovery'
-      ? {
-          status: resources.length > 0 ? 'outdated' : 'valid',
-          resources: [...resources],
-        }
-      : { status: 'unknown', resources: [] };
-  }
-
-  const inventoryByType = new Map(inventory.map(item => [item.type, item]));
-  const changedResources = resources.filter(resource => {
-    const current = inventoryByType.get(resource.type);
-    return (
-      !current ||
-      current.size !== resource.size ||
-      current.headerHash.toLowerCase() !== resource.headerHash.toLowerCase()
-    );
-  });
-
-  return {
-    status: changedResources.length === 0 ? 'valid' : 'outdated',
-    resources: changedResources,
-  };
-}
-
-function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
-}
-
-/** Verify the complete downloaded file before any device mutation. */
-export function isProtocolV2ResourceFileValid(
-  binary: ArrayBuffer,
-  resource: Pick<IProtocolV2ResourceFile, 'size' | 'fileHash'>
-): boolean {
-  if (binary.byteLength !== resource.size) return false;
-  return bytesToHex(sha256(new Uint8Array(binary))) === resource.fileHash.toLowerCase();
-}

package/src/protocols/protocol-v2/unlockPolicyRunner.ts

@@ -1,131 +0,0 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
-
-import { LoggerNames, getLogger } from '../../utils';
-import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
-import { refreshProtocolV2DeviceStatus } from './walletSession';
-
-import type { BaseMethod } from '../../api/BaseMethod';
-import type { Device } from '../../device/Device';
-import type { HardwareUiInteractionMeta } from '../../events';
-import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
-
-const Log = getLogger(LoggerNames.Core);
-
-export type ProtocolV2UnlockContext = {
-  preflightCompleted: boolean;
-};
-
-export const createProtocolV2UnlockContext = (): ProtocolV2UnlockContext => ({
-  preflightCompleted: false,
-});
-
-type RunnableMethod = Pick<
-  BaseMethod,
-  | 'run'
-  | 'unlockPolicy'
-  | 'useDevicePassphraseState'
-  | 'protocolV2UiInteraction'
-  | 'protocolV2UiMode'
-  | 'params'
-  | 'payload'
-> & {
-  name?: string;
-  protocolV2UnlockContext?: ProtocolV2UnlockContext;
-};
-
-type UiInteractionCoordinator = Pick<
-  ProtocolV2UiInteractionCoordinator,
-  'enterMethodInteraction' | 'enterUnlockInteraction'
->;
-
-type RunMethodWithUnlockPolicyOptions<T> = {
-  context?: ProtocolV2UnlockContext;
-  uiCoordinator?: UiInteractionCoordinator;
-  afterStatusBeforeUnlock?: () => void | Promise<void>;
-  prepare?: () => Promise<void>;
-  run?: () => Promise<T>;
-};
-
-const resolvePreUnlockPinType = (method: RunnableMethod) => {
-  const targetsKnownHiddenWallet =
-    method.useDevicePassphraseState &&
-    method.payload?.useEmptyPassphrase !== true &&
-    typeof method.payload?.passphraseState === 'string' &&
-    method.payload.passphraseState.length > 0;
-
-  // A hidden-wallet call may be unlocked by either its Attach PIN or the main
-  // PIN followed by passphrase selection. Wallet-session verification still
-  // rejects a different hidden wallet after the device is unlocked.
-  return targetsKnownHiddenWallet ? DeviceSessionPinType.Any : DeviceSessionPinType.Main;
-};
-
-export async function runMethodWithUnlockPolicy<T = unknown>(
-  method: RunnableMethod,
-  device: Device,
-  options: RunMethodWithUnlockPolicyOptions<T> = {}
-): Promise<T> {
-  const {
-    context = createProtocolV2UnlockContext(),
-    uiCoordinator,
-    afterStatusBeforeUnlock,
-    prepare,
-    run: configuredRun,
-  } = options;
-  const run = configuredRun ?? (() => method.run() as Promise<T>);
-  method.protocolV2UnlockContext = context;
-
-  const shouldEmitUi = isProtocolV2UiEnabled(method);
-  const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
-  const requiresPreUnlock =
-    device.isProtocolV2() &&
-    (method.useDevicePassphraseState || method.unlockPolicy === 'unlock-before-run') &&
-    !device.isBootloader?.() &&
-    !device.isRomloader?.();
-
-  if (requiresPreUnlock && !context.preflightCompleted) {
-    const status = await refreshProtocolV2DeviceStatus(device);
-    if (typeof status?.unlocked !== 'boolean') {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 DeviceStatus did not report an explicit unlock state.'
-      );
-    }
-
-    await afterStatusBeforeUnlock?.();
-
-    if (!status.unlocked) {
-      const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
-        ? uiCoordinator.enterUnlockInteraction(method.name)
-        : undefined;
-      const unlockedStatus = await device.unlockDevice(
-        resolvePreUnlockPinType(method),
-        shouldCoordinateUi
-          ? { emitUiEvent: false, interaction: unlockInteraction }
-          : {
-              source: 'unlock-coordinator',
-              reason: 'device-locked',
-              deviceOnly: true,
-              method: method.name,
-            }
-      );
-      if (unlockedStatus?.unlocked !== true) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Protocol V2 device remained locked after the unlock flow.'
-        );
-      }
-      Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
-    }
-
-    context.preflightCompleted = true;
-  }
-
-  await prepare?.();
-
-  if (shouldCoordinateUi) {
-    uiCoordinator.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
-  }
-
-  return run();
-}

package/src/types/api/detectDeviceConnectProtocol.ts

@@ -1,6 +0,0 @@
-import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
-import type { Response } from '../params';
-
-export declare function detectDeviceConnectProtocol(
-  connectId: string
-): Response<HardwareConnectProtocol>;

package/src/utils/pro2Nft.ts

@@ -1,142 +0,0 @@
-import { blake2s } from '@noble/hashes/blake2s';
-import { bytesToHex } from '@noble/hashes/utils';
-
-import { invalidParameter } from '../api/helpers/filesystemValidation';
-import { encodePro2Image } from './pro2Wallpaper';
-
-export const PRO2_NFT_IMAGE_WIDTH = 540;
-export const PRO2_NFT_IMAGE_HEIGHT = 540;
-export const PRO2_NFT_THUMBNAIL_WIDTH = 263;
-export const PRO2_NFT_THUMBNAIL_HEIGHT = 263;
-export const PRO2_NFT_DIRECTORY = 'vol1:/nft';
-export const PRO2_NFT_DEFAULT_CHUNK_SIZE = 2048;
-export const PRO2_NFT_DEFAULT_PACE_MS = 0;
-export const PRO2_NFT_DEFAULT_TIMEOUT_MS = 15_000;
-export const PRO2_NFT_MIN_CHUNK_SIZE = 64;
-export const PRO2_NFT_MAX_CHUNK_SIZE = 2048;
-export const PRO2_NFT_MAX_ITEMS = 10;
-
-export type Pro2NftImage = {
-  width: number;
-  height: number;
-  rgba: Uint8Array | ArrayBuffer;
-};
-
-export type Pro2NftBundle = {
-  basename: string;
-  image: Uint8Array;
-  thumbnail: Uint8Array;
-  metadata: Uint8Array;
-};
-
-const PRO2_NFT_BASENAME_PATTERN = /^nft-[0-9a-f]{8}-[1-9][0-9]*$/;
-
-type Pro2NftFileType = 'image' | 'thumbnail' | 'metadata';
-
-function parsePro2NftFile(listedPath: string):
-  | {
-      basename: string;
-      fileType: Pro2NftFileType;
-    }
-  | undefined {
-  const filename = listedPath.trim().split('/').at(-1);
-  if (!filename) return undefined;
-
-  let basename: string | undefined;
-  let fileType: Pro2NftFileType | undefined;
-  if (filename.endsWith('_m.bin')) {
-    basename = filename.slice(0, -'_m.bin'.length);
-    fileType = 'thumbnail';
-  } else if (filename.endsWith('.json')) {
-    basename = filename.slice(0, -'.json'.length);
-    fileType = 'metadata';
-  } else if (filename.endsWith('.bin')) {
-    basename = filename.slice(0, -'.bin'.length);
-    fileType = 'image';
-  }
-
-  return basename && fileType && PRO2_NFT_BASENAME_PATTERN.test(basename)
-    ? { basename, fileType }
-    : undefined;
-}
-
-export function getCompletePro2NftBasenames(childFiles?: string): Set<string> {
-  const filesByBasename = new Map<string, Set<Pro2NftFileType>>();
-
-  for (const listedPath of childFiles?.split('\n') ?? []) {
-    const file = parsePro2NftFile(listedPath);
-    if (file) {
-      const fileTypes = filesByBasename.get(file.basename) ?? new Set<Pro2NftFileType>();
-      fileTypes.add(file.fileType);
-      filesByBasename.set(file.basename, fileTypes);
-    }
-  }
-
-  return new Set(
-    [...filesByBasename.entries()]
-      .filter(([, fileTypes]) => fileTypes.size === 3)
-      .map(([basename]) => basename)
-  );
-}
-
-function utf8Length(value: string): number {
-  return new TextEncoder().encode(value).byteLength;
-}
-
-function assertImage(
-  name: string,
-  image: Pro2NftImage,
-  expectedWidth: number,
-  expectedHeight: number
-) {
-  if (image.width !== expectedWidth || image.height !== expectedHeight) {
-    throw invalidParameter(
-      `Pro2 NFT ${name} dimensions must be ${expectedWidth}x${expectedHeight}.`
-    );
-  }
-  if (!(image.rgba instanceof ArrayBuffer) && !ArrayBuffer.isView(image.rgba)) {
-    throw invalidParameter(`Parameter [${name}.rgba] must be an ArrayBuffer or Uint8Array.`);
-  }
-}
-
-export function buildPro2NftBundle(options: {
-  image: Pro2NftImage;
-  thumbnail: Pro2NftImage;
-  title: string;
-  subtitle: string;
-  timestampMs: number;
-}): Pro2NftBundle {
-  const { image, thumbnail, title, subtitle, timestampMs } = options;
-  assertImage('image', image, PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT);
-  assertImage('thumbnail', thumbnail, PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT);
-  const titleLength = typeof title === 'string' ? utf8Length(title) : 0;
-  const subtitleLength =
-    typeof subtitle === 'string' ? utf8Length(subtitle) : Number.POSITIVE_INFINITY;
-  if (titleLength < 1 || titleLength > 63) {
-    throw invalidParameter('Pro2 NFT title must contain 1 to 63 UTF-8 bytes.');
-  }
-  if (subtitleLength > 95) {
-    throw invalidParameter('Pro2 NFT subtitle must contain at most 95 UTF-8 bytes.');
-  }
-  if (!Number.isSafeInteger(timestampMs) || timestampMs <= 0) {
-    throw invalidParameter('Parameter [timestampMs] must be a positive safe integer.');
-  }
-
-  const encodedImage = encodePro2Image({ ...image, alphaMode: 'black-background' }).data;
-  const encodedThumbnail = encodePro2Image({
-    ...thumbnail,
-    alphaMode: 'black-background',
-  }).data;
-  const metadata = new TextEncoder().encode(JSON.stringify({ title, subtitle }));
-  if (metadata.byteLength === 0 || metadata.byteLength > 512) {
-    throw invalidParameter('Pro2 NFT metadata must contain 1 to 512 UTF-8 bytes.');
-  }
-
-  const hash8 = bytesToHex(blake2s(encodedImage)).slice(0, 8);
-  return {
-    basename: `nft-${hash8}-${timestampMs}`,
-    image: encodedImage,
-    thumbnail: encodedThumbnail,
-    metadata,
-  };
-}