@onekeyfe/hd-core 1.2.0-alpha.102 → 1.2.0-alpha.103

package/src/api/protocol-v2/DeviceUploadNft.ts

@@ -7,21 +7,26 @@ import {
   PRO2_NFT_DEFAULT_PACE_MS,
   PRO2_NFT_DEFAULT_TIMEOUT_MS,
   PRO2_NFT_DIRECTORY,
+  PRO2_NFT_IMAGE_HEIGHT,
+  PRO2_NFT_IMAGE_WIDTH,
   PRO2_NFT_MAX_CHUNK_SIZE,
   PRO2_NFT_MAX_ITEMS,
   PRO2_NFT_MIN_CHUNK_SIZE,
+  PRO2_NFT_THUMBNAIL_HEIGHT,
+  PRO2_NFT_THUMBNAIL_WIDTH,
   type Pro2NftBundle,
-  type Pro2NftImage,
-  buildPro2NftBundle,
+  buildPro2NftBundleFromEncodedImages,
   getCompletePro2NftBasenames,
 } from '../../utils/pro2Nft';
+import { encodePro2Image } from '../../utils/pro2Wallpaper';
 import { BaseMethod } from '../BaseMethod';
+import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
 import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
 
 export type DeviceUploadNftParams = {
-  image: Pro2NftImage;
-  thumbnail: Pro2NftImage;
+  imageJpegBase64: string;
+  thumbnailJpegBase64: string;
   title: string;
   subtitle: string;
   timestampMs?: number;
@@ -54,8 +59,8 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
 
   init() {
     const {
-      image,
-      thumbnail,
+      imageJpegBase64,
+      thumbnailJpegBase64,
       title,
       subtitle,
       timestampMs = Date.now(),
@@ -79,8 +84,51 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
       throw invalidParameter('Parameter [timeoutMs] must be a positive integer.');
     }
 
-    this.bundle = buildPro2NftBundle({ image, thumbnail, title, subtitle, timestampMs });
-    this.params = { image, thumbnail, title, subtitle, timestampMs, chunkSize, paceMs, timeoutMs };
+    const encodedImage = (() => {
+      const decoded = decodeJpegBase64ToRgba({
+        jpegBase64: imageJpegBase64,
+        parameterName: 'imageJpegBase64',
+        expectedWidth: PRO2_NFT_IMAGE_WIDTH,
+        expectedHeight: PRO2_NFT_IMAGE_HEIGHT,
+      });
+      return encodePro2Image({
+        width: PRO2_NFT_IMAGE_WIDTH,
+        height: PRO2_NFT_IMAGE_HEIGHT,
+        rgba: decoded.data,
+        alphaMode: 'black-background',
+      }).data;
+    })();
+    const encodedThumbnail = (() => {
+      const decoded = decodeJpegBase64ToRgba({
+        jpegBase64: thumbnailJpegBase64,
+        parameterName: 'thumbnailJpegBase64',
+        expectedWidth: PRO2_NFT_THUMBNAIL_WIDTH,
+        expectedHeight: PRO2_NFT_THUMBNAIL_HEIGHT,
+      });
+      return encodePro2Image({
+        width: PRO2_NFT_THUMBNAIL_WIDTH,
+        height: PRO2_NFT_THUMBNAIL_HEIGHT,
+        rgba: decoded.data,
+        alphaMode: 'black-background',
+      }).data;
+    })();
+    this.bundle = buildPro2NftBundleFromEncodedImages({
+      image: encodedImage,
+      thumbnail: encodedThumbnail,
+      title,
+      subtitle,
+      timestampMs,
+    });
+    this.params = {
+      imageJpegBase64,
+      thumbnailJpegBase64,
+      title,
+      subtitle,
+      timestampMs,
+      chunkSize,
+      paceMs,
+      timeoutMs,
+    };
     this.unlockPolicy = 'none';
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -1,10 +1,13 @@
 import { blake2s } from '@noble/hashes/blake2s';
 import { bytesToHex } from '@noble/hashes/utils';
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
 
 import { BaseMethod } from '../BaseMethod';
+import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
 import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
 import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
 import {
   PRO2_WALLPAPER_HEIGHT,
   PRO2_WALLPAPER_WIDTH,
@@ -13,9 +16,7 @@ import {
 } from '../../utils/pro2Wallpaper';
 
 export type DeviceUploadWallpaperParams = {
-  width: number;
-  height: number;
-  rgba: Uint8Array | ArrayBuffer;
+  jpegBase64: string;
   fileName?: string;
   chunkSize?: number;
 };
@@ -29,6 +30,9 @@ export type DeviceUploadWallpaperResponse = {
 
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
+const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
+const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
+const FILESYSTEM_DIR_MAKE_MESSAGE_TYPE = 60809;
 
 function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
   if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
@@ -54,31 +58,45 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
   private path = '';
 
   init() {
-    const { width, height, rgba, fileName, chunkSize } = this.payload;
-    if (width !== PRO2_WALLPAPER_WIDTH || height !== PRO2_WALLPAPER_HEIGHT) {
-      throw invalidParameter(
-        `Pro2 wallpaper dimensions must be ${PRO2_WALLPAPER_WIDTH}x${PRO2_WALLPAPER_HEIGHT}.`
-      );
-    }
-    if (!(rgba instanceof ArrayBuffer) && !ArrayBuffer.isView(rgba)) {
-      throw invalidParameter('Parameter [rgba] must be an ArrayBuffer or Uint8Array.');
-    }
+    const { jpegBase64, fileName, chunkSize } = this.payload;
     if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
       throw invalidParameter('Parameter [chunkSize] must be a positive integer.');
     }
 
-    const rgbaBytes =
-      rgba instanceof ArrayBuffer
-        ? rgba
-        : new Uint8Array(rgba.buffer, rgba.byteOffset, rgba.byteLength);
-    this.encoded = encodePro2Wallpaper({ width, height, rgba: rgbaBytes });
+    const decoded = decodeJpegBase64ToRgba({
+      jpegBase64,
+      parameterName: 'jpegBase64',
+      expectedWidth: PRO2_WALLPAPER_WIDTH,
+      expectedHeight: PRO2_WALLPAPER_HEIGHT,
+    });
+    this.encoded = encodePro2Wallpaper({
+      width: PRO2_WALLPAPER_WIDTH,
+      height: PRO2_WALLPAPER_HEIGHT,
+      rgba: decoded.data,
+    });
     this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
-    this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
+    this.params = { jpegBase64, fileName, chunkSize };
     this.unlockPolicy = 'none';
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
   }
 
+  private async assertCapabilities() {
+    const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
+    const requiredMessageTypes = [
+      DEVICE_SETTINGS_SET_MESSAGE_TYPE,
+      FILESYSTEM_FILE_WRITE_MESSAGE_TYPE,
+      FILESYSTEM_DIR_MAKE_MESSAGE_TYPE,
+    ];
+    if (
+      requiredMessageTypes.some(
+        messageType => !supportsProtocolV2Message(protocolInfo, messageType)
+      )
+    ) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+  }
+
   private async ensureDirectory() {
     if (this.directoryReady) return;
     try {
@@ -119,6 +137,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
   async run(): Promise<DeviceUploadWallpaperResponse> {
     const { encoded } = this;
     if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+    await this.assertCapabilities();
     await this.ensureDirectory();
     await this.upload();
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {

package/src/api/utils.ts

@@ -1,7 +1,6 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import * as ApiMethods from './index';
-import { decodeBridgeBinaryPayload } from '../utils/bridgeBinaryPayload';
 
 import type { BaseMethod } from './BaseMethod';
 import type { IFrameCallMessage } from '../events';
@@ -12,16 +11,14 @@ type MethodConstructor = new (message: IFrameCallMessage & { id?: number }) => B
 const publicMethodRegistry = ApiMethods as unknown as Record<string, MethodConstructor>;
 
 export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMethod<any> {
-  const payload = decodeBridgeBinaryPayload(message.payload) as IFrameCallMessage['payload'];
-  const normalizedMessage = payload === message.payload ? message : { ...message, payload };
-  const { method } = payload;
+  const { method } = message.payload;
   if (typeof method !== 'string') {
     throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
   }
 
   const MethodConstructor = publicMethodRegistry[method];
   if (MethodConstructor) {
-    return new MethodConstructor(normalizedMessage);
+    return new MethodConstructor(message);
   }
 
   throw ERRORS.TypedError(

package/src/topLevelInject.ts

@@ -2,7 +2,6 @@ import EventEmitter from 'events';
 
 import { createCoreApi, createProtocolAwareCall } from './inject';
 import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
-import { encodeBridgeBinaryPayload } from './utils/bridgeBinaryPayload';
 
 import type { ConnectSettings } from './types/settings';
 import type { CoreApi } from './types/api';
@@ -17,10 +16,9 @@ const eventEmitter = new EventEmitter();
 
 export const topLevelInject = () => {
   let lowLevelApi: LowLevelCoreApi | undefined;
-  const call = async (params: any) => {
+  const call = (params: any) => {
     if (!lowLevelApi) return Promise.resolve(undefined);
-    const encodedParams = await encodeBridgeBinaryPayload(params);
-    return lowLevelApi.call(encodedParams as any);
+    return lowLevelApi.call(params);
   };
   const protocolAwareCall = createProtocolAwareCall(call);
   const api: CoreApi = {

package/src/types/api/protocolV2.ts

@@ -68,7 +68,7 @@ export declare function deviceUploadNft(
 export declare function uploadPortfolio(
   connectId: string,
   params: {
-    packageBytes: ArrayBuffer | Uint8Array | Blob;
+    packageBase64: string;
     timeoutMs?: number | string;
   }
 ): Response<FileInfo & { portfolioUpdated: true }>;

package/src/utils/pro2Nft.ts

@@ -109,6 +109,34 @@ export function buildPro2NftBundle(options: {
   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 encodedImage = encodePro2Image({ ...image, alphaMode: 'black-background' }).data;
+  const encodedThumbnail = encodePro2Image({
+    ...thumbnail,
+    alphaMode: 'black-background',
+  }).data;
+  return buildPro2NftBundleFromEncodedImages({
+    image: encodedImage,
+    thumbnail: encodedThumbnail,
+    title,
+    subtitle,
+    timestampMs,
+  });
+}
+
+export function buildPro2NftBundleFromEncodedImages(options: {
+  image: Uint8Array;
+  thumbnail: Uint8Array;
+  title: string;
+  subtitle: string;
+  timestampMs: number;
+}): Pro2NftBundle {
+  const { image, thumbnail, title, subtitle, timestampMs } = options;
+  if (!(image instanceof Uint8Array) || image.byteLength === 0) {
+    throw invalidParameter('Parameter [image] must contain encoded NFT image data.');
+  }
+  if (!(thumbnail instanceof Uint8Array) || thumbnail.byteLength === 0) {
+    throw invalidParameter('Parameter [thumbnail] must contain encoded NFT thumbnail data.');
+  }
   const titleLength = typeof title === 'string' ? utf8Length(title) : 0;
   const subtitleLength =
     typeof subtitle === 'string' ? utf8Length(subtitle) : Number.POSITIVE_INFINITY;
@@ -122,21 +150,16 @@ export function buildPro2NftBundle(options: {
     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);
+  const hash8 = bytesToHex(blake2s(image)).slice(0, 8);
   return {
     basename: `nft-${hash8}-${timestampMs}`,
-    image: encodedImage,
-    thumbnail: encodedThumbnail,
+    image,
+    thumbnail,
     metadata,
   };
 }

package/__tests__/bridgeBinaryPayload.test.ts

@@ -1,173 +0,0 @@
-import { HardwareTopLevelSdk } from '../src';
-import { findMethod } from '../src/api/utils';
-import {
-  decodeBridgeBinaryPayload,
-  encodeBridgeBinaryPayload,
-} from '../src/utils/bridgeBinaryPayload';
-
-import type { LowLevelCoreApi } from '../src';
-
-jest.mock('../src/data/config', () => ({
-  DEFAULT_DOMAIN: 'https://example.com/',
-  getSDKVersion: () => '0.0.0-test',
-}));
-
-const crossJsonOnlyBridge = (value: unknown): unknown => JSON.parse(JSON.stringify(value));
-
-describe('bridge binary payload', () => {
-  test('preserves nested ArrayBuffer and sliced Uint8Array values', async () => {
-    const arrayBuffer = new Uint8Array([1, 2, 3]).buffer;
-    const backing = new Uint8Array([90, 4, 5, 6, 91]);
-    const encoded = await encodeBridgeBinaryPayload({
-      arrayBuffer,
-      bytes: backing.subarray(1, 4),
-    });
-    const decoded = decodeBridgeBinaryPayload(crossJsonOnlyBridge(encoded)) as {
-      arrayBuffer: ArrayBuffer;
-      bytes: Uint8Array;
-    };
-
-    expect(decoded.arrayBuffer).toBeInstanceOf(ArrayBuffer);
-    expect(Array.from(new Uint8Array(decoded.arrayBuffer))).toEqual([1, 2, 3]);
-    expect(decoded.bytes).toBeInstanceOf(Uint8Array);
-    expect(Array.from(decoded.bytes)).toEqual([4, 5, 6]);
-  });
-
-  test('encodes Blob input as byte data', async () => {
-    const encoded = await encodeBridgeBinaryPayload(new Blob([new Uint8Array([7, 8])]));
-    const decoded = decodeBridgeBinaryPayload(crossJsonOnlyBridge(encoded));
-
-    expect(decoded).toBeInstanceOf(Uint8Array);
-    expect(Array.from(decoded as Uint8Array)).toEqual([7, 8]);
-  });
-
-  test('routes portfolio, wallpaper and NFT bytes through the top-level boundary', async () => {
-    const restoredPayloads: Array<Record<string, any>> = [];
-    const lowLevelApi = {
-      call: jest.fn(params => {
-        const wirePayload = crossJsonOnlyBridge(params);
-        const method = findMethod({ id: 1, payload: wirePayload } as any);
-        restoredPayloads.push(method.payload);
-        return Promise.resolve({ success: true, payload: {} });
-      }),
-      init: jest.fn(() => Promise.resolve(true)),
-    } as unknown as LowLevelCoreApi;
-    const sdk = HardwareTopLevelSdk();
-    await sdk.init({}, lowLevelApi);
-
-    const portfolioBytes = new Uint8Array([1, 2, 3]).buffer;
-    const wallpaperBacking = new Uint8Array([90, 4, 5, 6, 91]);
-    const nftBacking = new Uint8Array([80, 7, 8, 9, 10, 81]);
-    await sdk.uploadPortfolio('connect-id', { packageBytes: portfolioBytes });
-    await sdk.deviceUploadWallpaper('connect-id', {
-      width: 604,
-      height: 1024,
-      rgba: wallpaperBacking.subarray(1, 4),
-    });
-    await sdk.deviceUploadNft('connect-id', {
-      image: { width: 540, height: 540, rgba: nftBacking.subarray(1, 3) },
-      thumbnail: { width: 263, height: 263, rgba: nftBacking.subarray(3, 5) },
-      title: 'NFT',
-      subtitle: '',
-    });
-
-    expect(Array.from(new Uint8Array(restoredPayloads[0].packageBytes))).toEqual([1, 2, 3]);
-    expect(Array.from(restoredPayloads[1].rgba)).toEqual([4, 5, 6]);
-    expect(Array.from(restoredPayloads[2].image.rgba)).toEqual([7, 8]);
-    expect(Array.from(restoredPayloads[2].thumbnail.rgba)).toEqual([9, 10]);
-  });
-
-  test('routes firmware update binaries through the top-level boundary', async () => {
-    const restoredPayloads: Array<Record<string, any>> = [];
-    const lowLevelApi = {
-      call: jest.fn(params => {
-        const wirePayload = crossJsonOnlyBridge(params);
-        const method = findMethod({ id: 1, payload: wirePayload } as any);
-        restoredPayloads.push(method.payload);
-        return Promise.resolve({ success: true, payload: {} });
-      }),
-      init: jest.fn(() => Promise.resolve(true)),
-    } as unknown as LowLevelCoreApi;
-    const sdk = HardwareTopLevelSdk();
-    await sdk.init({}, lowLevelApi);
-    const binary = (...bytes: number[]) => Uint8Array.from(bytes).buffer;
-
-    await sdk.firmwareUpdate('connect-id', {
-      binary: binary(1),
-      updateType: 'firmware',
-    });
-    await sdk.firmwareUpdateV2('connect-id', {
-      binary: binary(2),
-      updateType: 'firmware',
-      platform: 'ext',
-    });
-    await sdk.firmwareUpdateV3('connect-id', {
-      platform: 'ext',
-      bleBinary: binary(3),
-      firmwareBinary: binary(4),
-      bootloaderBinary: binary(5),
-      resourceBinary: binary(6),
-    });
-    await sdk.firmwareUpdateV4('connect-id', {
-      platform: 'ext',
-      targetsToUpdate: [
-        'boot',
-        'app_v1',
-        'app_v2',
-        'coprocessor',
-        'se01',
-        'se02',
-        'se03',
-        'se04',
-        'resource',
-      ],
-      romloaderBinary: binary(7),
-      bootloaderBinary: binary(8),
-      applicationP1Binary: binary(9),
-      applicationP2Binary: binary(10),
-      coprocessorBinary: binary(11),
-      se01Binary: binary(12),
-      se02Binary: binary(13),
-      se03Binary: binary(14),
-      se04Binary: binary(15),
-      resourceArchiveBinary: binary(16),
-    });
-    await sdk.deviceUpdateBootloader('connect-id', { binary: binary(17) });
-    await sdk.deviceFullyUploadResource('connect-id', { binary: binary(18) });
-
-    expect(restoredPayloads).toHaveLength(6);
-    const restoredBinaries = [
-      restoredPayloads[0].binary,
-      restoredPayloads[1].binary,
-      restoredPayloads[2].bleBinary,
-      restoredPayloads[2].firmwareBinary,
-      restoredPayloads[2].bootloaderBinary,
-      restoredPayloads[2].resourceBinary,
-      restoredPayloads[3].romloaderBinary,
-      restoredPayloads[3].bootloaderBinary,
-      restoredPayloads[3].applicationP1Binary,
-      restoredPayloads[3].applicationP2Binary,
-      restoredPayloads[3].coprocessorBinary,
-      restoredPayloads[3].se01Binary,
-      restoredPayloads[3].se02Binary,
-      restoredPayloads[3].se03Binary,
-      restoredPayloads[3].se04Binary,
-      restoredPayloads[3].resourceArchiveBinary,
-      restoredPayloads[4].binary,
-      restoredPayloads[5].binary,
-    ];
-    expect(restoredBinaries.map(value => Array.from(new Uint8Array(value)))).toEqual(
-      Array.from({ length: 18 }, (_, index) => [index + 1])
-    );
-  });
-
-  test('rejects malformed tagged binary data', () => {
-    expect(() =>
-      decodeBridgeBinaryPayload({
-        __onekey_hd_bridge_binary_payload__: 1,
-        data: 'not-base64',
-        type: 'uint8-array',
-      })
-    ).toThrow('Invalid bridge binary payload data');
-  });
-});

package/dist/utils/bridgeBinaryPayload.d.ts

@@ -1,3 +0,0 @@
-export declare function encodeBridgeBinaryPayload(value: unknown): Promise<unknown>;
-export declare function decodeBridgeBinaryPayload(value: unknown): unknown;
-//# sourceMappingURL=bridgeBinaryPayload.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"bridgeBinaryPayload.d.ts","sourceRoot":"","sources":["../../src/utils/bridgeBinaryPayload.ts"],"names":[],"mappings":"AAkIA,wBAAsB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAEhF;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEjE"}

package/src/utils/bridgeBinaryPayload.ts

@@ -1,137 +0,0 @@
-import { Buffer } from 'buffer';
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-// Top-level and low-level SDK instances can be separated by JSON-only hosts,
-// including browser extension background/offscreen message bridges.
-const BRIDGE_BINARY_PAYLOAD_MARKER = '__onekey_hd_bridge_binary_payload__';
-
-type BridgeBinaryPayload = {
-  [BRIDGE_BINARY_PAYLOAD_MARKER]: 1;
-  data: string;
-  type: 'array-buffer' | 'uint8-array';
-};
-
-const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-
-const invalidBinaryPayload = (message: string) =>
-  ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-
-function isArrayBufferValue(value: unknown): value is ArrayBuffer {
-  return Boolean(
-    typeof ArrayBuffer !== 'undefined' &&
-      (value instanceof ArrayBuffer ||
-        Object.prototype.toString.call(value) === '[object ArrayBuffer]')
-  );
-}
-
-function isBlobValue(value: unknown): value is Blob {
-  return Boolean(
-    typeof Blob !== 'undefined' &&
-      (value instanceof Blob || Object.prototype.toString.call(value) === '[object Blob]') &&
-      typeof (value as Blob).arrayBuffer === 'function'
-  );
-}
-
-function readBinaryPayload(value: unknown): BridgeBinaryPayload | undefined {
-  if (!isPlainObject(value) || !(BRIDGE_BINARY_PAYLOAD_MARKER in value)) return undefined;
-  const payload = value as Partial<BridgeBinaryPayload>;
-  if (
-    payload[BRIDGE_BINARY_PAYLOAD_MARKER] !== 1 ||
-    (payload.type !== 'array-buffer' && payload.type !== 'uint8-array') ||
-    typeof payload.data !== 'string'
-  ) {
-    throw invalidBinaryPayload('Invalid bridge binary payload');
-  }
-  return payload as BridgeBinaryPayload;
-}
-
-function bytesToPayload(bytes: Uint8Array, type: BridgeBinaryPayload['type']): BridgeBinaryPayload {
-  return {
-    [BRIDGE_BINARY_PAYLOAD_MARKER]: 1,
-    data: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64'),
-    type,
-  };
-}
-
-function payloadToBytes(payload: BridgeBinaryPayload): Uint8Array {
-  if (payload.data.length % 4 !== 0 || !BASE64_PATTERN.test(payload.data)) {
-    throw invalidBinaryPayload('Invalid bridge binary payload data');
-  }
-  const decoded = Buffer.from(payload.data, 'base64');
-  if (decoded.toString('base64') !== payload.data) {
-    throw invalidBinaryPayload('Invalid bridge binary payload data');
-  }
-  return Uint8Array.from(decoded);
-}
-
-async function encodeValue(value: unknown, seen: WeakSet<object>): Promise<unknown> {
-  if (isArrayBufferValue(value)) {
-    return bytesToPayload(new Uint8Array(value), 'array-buffer');
-  }
-  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(value)) {
-    return bytesToPayload(
-      new Uint8Array(value.buffer, value.byteOffset, value.byteLength),
-      'uint8-array'
-    );
-  }
-  if (isBlobValue(value)) {
-    return bytesToPayload(new Uint8Array(await value.arrayBuffer()), 'uint8-array');
-  }
-
-  const encodedPayload = readBinaryPayload(value);
-  if (encodedPayload) return encodedPayload;
-  if (Array.isArray(value)) {
-    if (seen.has(value)) throw invalidBinaryPayload('Circular bridge payload');
-    seen.add(value);
-    try {
-      const encoded: unknown[] = [];
-      for (const item of value) {
-        encoded.push(await encodeValue(item, seen));
-      }
-      return encoded.some((item, index) => item !== value[index]) ? encoded : value;
-    } finally {
-      seen.delete(value);
-    }
-  }
-  if (!isPlainObject(value)) return value;
-  if (seen.has(value)) throw invalidBinaryPayload('Circular bridge payload');
-  seen.add(value);
-  try {
-    const entries: [string, unknown][] = [];
-    for (const [key, item] of Object.entries(value)) {
-      entries.push([key, await encodeValue(item, seen)]);
-    }
-    return entries.some(([key, item]) => item !== value[key]) ? Object.fromEntries(entries) : value;
-  } finally {
-    seen.delete(value);
-  }
-}
-
-function decodeValue(value: unknown): unknown {
-  const payload = readBinaryPayload(value);
-  if (payload) {
-    const bytes = payloadToBytes(payload);
-    return payload.type === 'array-buffer' ? bytes.buffer : bytes;
-  }
-  if (Array.isArray(value)) {
-    const decoded = value.map(decodeValue);
-    return decoded.some((item, index) => item !== value[index]) ? decoded : value;
-  }
-  if (!isPlainObject(value)) return value;
-  const entries = Object.entries(value).map(([key, item]) => [key, decodeValue(item)] as const);
-  return entries.some(([key, item]) => item !== value[key]) ? Object.fromEntries(entries) : value;
-}
-
-export async function encodeBridgeBinaryPayload(value: unknown): Promise<unknown> {
-  return encodeValue(value, new WeakSet());
-}
-
-export function decodeBridgeBinaryPayload(value: unknown): unknown {
-  return decodeValue(value);
-}