@onekeyfe/hd-core 1.2.0-alpha.23 → 1.2.0-alpha.25

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -25,6 +25,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       connectId: 'connect-id',
       deviceId: 'device-id',
       getVersionRange: jest.fn().mockReturnValue({}),
+      assertProtocolSupported: jest.fn(),
       init: jest.fn(),
       name: 'xrpGetAddress',
       responseID: 42,
@@ -45,6 +46,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
     method.device = {
       instanceId: deviceInstanceId,
       getCurrentFirmwareType: jest.fn(),
+      getProtocol: jest.fn().mockReturnValue('V1'),
       getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
       getCurrentMethodVersionRange: jest
         .fn()

package/__tests__/DeviceCommands.test.ts

@@ -103,6 +103,41 @@ describe('DeviceCommands failure mapping', () => {
     ).rejects.toMatchObject({ errorCode: code });
   });
 
+  it.each([
+    ['DeviceSessionGet', 5, 'Another flow in progress'],
+    ['DeviceSessionAskPin', 0, 'Busy'],
+  ])('maps %s firmware busy failures to DeviceBusy', async (callType, subcode, message) => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: { code: 'Failure_ProcessError', subcode, message },
+        } as any,
+        callType
+      )
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceBusy });
+  });
+
+  it('maps the current AskPin passphrase-disabled response without relying on a subcode', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 0,
+            message: 'Passphrase disabled',
+          },
+        } as any,
+        'DeviceSessionAskPin'
+      )
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceNotOpenedPassphrase });
+  });
+
   it('rejects the Pro2 bootloader DeviceStatusGet unsupported response', async () => {
     const commands = createCommands();
 

package/__tests__/chain-params-onekey-compatibility.test.ts

@@ -0,0 +1,229 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import BenfenGetAddress from '../src/api/benfen/BenfenGetAddress';
+import ConfluxSignTransaction from '../src/api/conflux/ConfluxSignTransaction';
+import EVMSignTransaction from '../src/api/evm/EVMSignTransaction';
+import EVMSignMessageEIP712 from '../src/api/evm/EVMSignMessageEIP712';
+import KaspaSignTransaction from '../src/api/kaspa/KaspaSignTransaction';
+import XrpSignTransaction from '../src/api/xrp/XrpSignTransaction';
+
+import type { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  getProtocolV1MessageSchema: jest.fn(() => 'v1CurrentSchema'),
+}));
+
+jest.mock('../src/device/Device', () => ({
+  Device: jest.fn(),
+}));
+
+const KASPA_PATH = "m/44'/111111'/0'/0/0";
+const KASPA_SCRIPT = `20${'ab'.repeat(32)}ac`;
+const KASPA_ADDRESS = 'kaspa:qr0lr4ml9fn3chekrqmjdkergxl93l4wrk3dankcgvjq776s9wn9jkdskewva';
+
+const buildKaspaPayload = () => ({
+  method: 'kaspaSignTransaction',
+  version: 0,
+  lockTime: 0,
+  inputs: [
+    {
+      path: KASPA_PATH,
+      prevTxId: 'aa'.repeat(32),
+      outputIndex: 0,
+      sequenceNumber: 0,
+      output: { satoshis: 200000, script: KASPA_SCRIPT },
+    },
+  ],
+  outputs: [{ satoshis: 100000, script: KASPA_SCRIPT, scriptVersion: 0 }],
+});
+
+describe('onekey public-chain parameter compatibility', () => {
+  it('keeps the historical EVM contract-deployment representation', () => {
+    const transaction = {
+      to: '',
+      value: '0x0',
+      gasPrice: '0x1',
+      gasLimit: '0x5208',
+      nonce: '0x0',
+      chainId: 1,
+      data: '0x6000',
+    };
+
+    const method = new EVMSignTransaction({
+      id: 1,
+      payload: {
+        method: 'evmSignTransaction',
+        path: "m/44'/60'/0'/0/0",
+        transaction,
+      },
+    });
+
+    expect(() => method.init()).not.toThrow();
+
+    const { to: _to, ...transactionWithoutTo } = transaction;
+    const missingTo = new EVMSignTransaction({
+      id: 2,
+      payload: {
+        method: 'evmSignTransaction',
+        path: "m/44'/60'/0'/0/0",
+        transaction: transactionWithoutTo,
+      },
+    });
+
+    expect(() => missingTo.init()).toThrow('Missing required parameter: to');
+  });
+
+  it('keeps Conflux to validation aligned with onekey', () => {
+    const method = new ConfluxSignTransaction({
+      id: 1,
+      payload: {
+        method: 'confluxSignTransaction',
+        path: "m/44'/503'/0'/0/0",
+        transaction: {
+          to: 'cfx:aak2rra2njvd77ezwjvx04kkds9fzagfe6d5r8e957',
+          value: '0x0',
+          gasLimit: '0x5208',
+          gasPrice: '0x1',
+          nonce: '0x0',
+          epochHeight: '0x1',
+          storageLimit: '0x0',
+          chainId: 1029,
+        },
+      },
+    });
+
+    expect(() => method.init()).toThrow('should be [hexString]');
+  });
+
+  it('keeps XRP payment amount as the historical number input', () => {
+    const createMethod = (amount: number | string) =>
+      new XrpSignTransaction({
+        id: 1,
+        payload: {
+          method: 'xrpSignTransaction',
+          path: "m/44'/144'/0'/0/0",
+          transaction: {
+            payment: {
+              amount,
+              destination: 'rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn',
+            },
+          },
+        },
+      });
+
+    expect(() => createMethod(1).init()).not.toThrow();
+    expect(() => createMethod('1').init()).toThrow('should be [number]');
+  });
+
+  it('keeps the Kaspa legacy schema while allowing the additive streaming shape', () => {
+    const legacyWithoutSigHash = new KaspaSignTransaction({
+      id: 1,
+      payload: buildKaspaPayload(),
+    });
+    expect(() => legacyWithoutSigHash.init()).toThrow('Missing required parameter: sigHashType');
+
+    const legacyWithoutScript = new KaspaSignTransaction({
+      id: 2,
+      payload: {
+        ...buildKaspaPayload(),
+        sigHashType: 0x41,
+        outputs: [{ satoshis: 100000, scriptVersion: 0 }],
+      },
+    });
+    expect(() => legacyWithoutScript.init()).toThrow('Missing required parameter: script');
+
+    const streaming = new KaspaSignTransaction({
+      id: 3,
+      payload: {
+        ...buildKaspaPayload(),
+        inputs: [
+          {
+            ...buildKaspaPayload().inputs[0],
+            output: { satoshis: 200000 },
+          },
+        ],
+        outputs: [{ satoshis: 100000, address: KASPA_ADDRESS }],
+      },
+    });
+    expect(() => streaming.init()).not.toThrow();
+  });
+
+  it('keeps validating the Kaspa legacy input amount', () => {
+    const payload = buildKaspaPayload();
+    const method = new KaspaSignTransaction({
+      id: 1,
+      payload: {
+        ...payload,
+        sigHashType: 0x41,
+        inputs: [
+          {
+            ...payload.inputs[0],
+            output: { script: KASPA_SCRIPT },
+          },
+        ],
+      },
+    });
+
+    expect(() => method.init()).toThrow('Missing required parameter: satoshis');
+  });
+
+  it('keeps the deprecated EIP-712 method callable on existing Protocol V1 devices', async () => {
+    const method = new EVMSignMessageEIP712({
+      id: 1,
+      payload: {
+        method: 'evmSignMessageEIP712',
+        path: "m/44'/60'/0'/0/0",
+        domainHash: `0x${'11'.repeat(32)}`,
+        messageHash: `0x${'22'.repeat(32)}`,
+      },
+    });
+    method.init();
+
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        address: '0x1234',
+        signature: 'abcd',
+      },
+    });
+    method.device = {
+      commands: { typedCall },
+      getCurrentFirmwareVersionString: jest.fn(() => '4.10.0'),
+      getCurrentMethodVersionRange: jest.fn(() => undefined),
+      getCurrentFirmwareType: jest.fn(() => EFirmwareType.Universal),
+      getProtocol: jest.fn(() => 'V1'),
+    } as unknown as Device;
+
+    await expect(method.run()).resolves.toEqual({
+      address: '0x1234',
+      signature: 'abcd',
+    });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects a Benfen response that omits the address', async () => {
+    const method = new BenfenGetAddress({
+      id: 1,
+      payload: {
+        method: 'benfenGetAddress',
+        path: "m/44'/728'/0'/0'/0'",
+        showOnOneKey: false,
+      },
+    });
+    method.init();
+    method.device = {
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: {} }),
+      },
+      getCurrentFirmwareVersionString: jest.fn(() => '1.0.0'),
+      getCurrentDeviceType: jest.fn(() => EDeviceType.Classic),
+      isProtocolV2: jest.fn(() => false),
+    } as unknown as Device;
+
+    await expect(method.run()).rejects.toThrow(/address/i);
+  });
+});

package/__tests__/device-lifecycle-events.test.ts

@@ -1,3 +1,5 @@
+import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+
 import { initConnector, initCore } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
@@ -59,6 +61,63 @@ describe('public device lifecycle events', () => {
     jest.restoreAllMocks();
   });
 
+  test('registers the shared device lifecycle listeners exactly once', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+
+    for (const id of ['first-call', 'second-call']) {
+      await core.handleMessage({
+        id,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'clearSessionCache' },
+      } as CoreMessage);
+    }
+
+    expect(DevicePool.emitter.listenerCount(DEVICE.CONNECT)).toBe(1);
+    expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
+  });
+
+  test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+    const messages: CoreMessage[] = [];
+    core.on(CORE_EVENT, message => messages.push(message));
+    const device = createInitializedDevice('V2');
+    DevicePool.devicesCache['ble-connect-id'] = device;
+
+    DevicePool.emitter.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+      id: 'ble-connect-id',
+      connectId: 'ble-connect-id',
+      name: 'OneKey Test BLE',
+    });
+
+    const disconnectMessage = messages.find(message => message.type === DEVICE.DISCONNECT);
+    expect(disconnectMessage?.payload.device).toMatchObject({
+      connectId: 'ble-connect-id',
+      serialNo: 'SERIAL-001',
+      state: { protocol: 'V2' },
+    });
+    expect(() => JSON.stringify(disconnectMessage?.payload.device)).not.toThrow();
+  });
+
+  test('treats an acquired BLE device as reusable until the transport disconnects', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop-web-ble' as never);
+    const device = createInitializedDevice('V2');
+    const acquire = jest.spyOn(device, 'acquire').mockResolvedValue(undefined);
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+    (device as any).commands = { disposed: false };
+
+    expect(device.isUsedHere()).toBe(true);
+    await expect(device.connect('V2')).resolves.toBe(true);
+    expect(acquire).not.toHaveBeenCalled();
+
+    device.markTransportDisconnected();
+    expect(device.isUsedHere()).toBe(false);
+  });
+
   test.each([
     ['react-native', 'V1'],
     ['react-native', 'V2'],

package/__tests__/device-state-events.test.ts

@@ -1,3 +1,6 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
 import { Device } from '../src/device/Device';
 import { DEVICE } from '../src/events';
 import { EOneKeyDeviceMode } from '../src/types';
@@ -8,6 +11,127 @@ jest.mock('../src/data/config', () => ({
 }));
 
 describe('Device state events', () => {
+  test.each([
+    ['V1', EFirmwareType.BitcoinOnly],
+    ['V2', EFirmwareType.Universal],
+  ] as const)(
+    'reads the current %s firmware type from canonical state',
+    (protocol, firmwareType) => {
+      const device = Device.fromDescriptor({
+        id: `device-${protocol}`,
+        path: `device-${protocol}`,
+        protocolType: protocol,
+      } as never);
+      device.updateState({ protocol, identity: { firmwareType } }, 'initialize');
+      const featuresGetter = jest.spyOn(device, 'features', 'get').mockImplementation(() => {
+        throw new Error('Legacy Features projection should not be read');
+      });
+
+      expect(device.getCurrentFirmwareType()).toBe(firmwareType);
+      featuresGetter.mockRestore();
+    }
+  );
+
+  test('keeps the universal firmware fallback before device state is initialized', () => {
+    const device = Device.fromDescriptor({ id: 'pending', path: 'pending' } as never);
+
+    expect(device.getCurrentFirmwareType()).toBe(EFirmwareType.Universal);
+    expect(device.getCurrentDeviceType()).toBe(EDeviceType.Unknown);
+    expect(device.getCurrentDeviceId()).toBeUndefined();
+    expect(device.getCurrentSerialNo()).toBe('');
+    expect(device.getCurrentBleName()).toBeNull();
+    expect(device.getCurrentLabel()).toBeNull();
+    expect(device.getCurrentFirmwareVersionString()).toBe('0.0.0');
+    expect(device.getCurrentBLEFirmwareVersionString()).toBeUndefined();
+    expect(device.getCurrentBootloaderVersionString()).toBeUndefined();
+    expect(device.getFirmwareVersion()).toBeNull();
+    expect(device.getBLEFirmwareVersion()).toBeNull();
+    expect(device.isUnacquired()).toBe(true);
+  });
+
+  test('reads current device data from canonical state without projecting Features', () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2-state',
+      path: 'pro2-state',
+      protocolType: 'V2',
+    } as never);
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: {
+          deviceType: EDeviceType.Pro2,
+          deviceId: 'wallet-id',
+          serialNo: 'SERIAL-PRO2',
+          label: null,
+          bleName: 'Pro2 1234',
+        },
+        status: {
+          mode: 'normal',
+          initialized: true,
+          unlocked: false,
+          noBackup: false,
+          passphraseProtection: false,
+        },
+        settings: { safetyChecks: Enum_SafetyCheckLevel.Strict },
+        versions: {
+          firmware: '5.1.2',
+          bootloader: '2.0.0',
+          ble: null,
+        },
+      },
+      'initialize'
+    );
+    const featuresGetter = jest.spyOn(device, 'features', 'get').mockImplementation(() => {
+      throw new Error('Legacy Features projection should not be read');
+    });
+
+    expect(device.getCurrentDeviceType()).toBe(EDeviceType.Pro2);
+    expect(device.getCurrentDeviceId()).toBe('wallet-id');
+    expect(device.getCurrentSerialNo()).toBe('SERIAL-PRO2');
+    expect(device.getCurrentBleName()).toBe('Pro2 1234');
+    expect(device.getCurrentLabel()).toBeNull();
+    expect((device as any).getCurrentDisplayName()).toBe('Pro2 1234');
+    expect(device.getCurrentPassphraseProtection()).toBe(false);
+    expect(device.getCurrentFirmwareVersionString()).toBe('5.1.2');
+    expect(device.getCurrentBLEFirmwareVersionString()).toBe('0.0.0');
+    expect(device.getCurrentBootloaderVersionString()).toBe('2.0.0');
+    expect(device.getCurrentSafetyChecks()).toBe(Enum_SafetyCheckLevel.Strict);
+    expect(device.getFirmwareVersion()).toEqual([5, 1, 2]);
+    expect(device.getBLEFirmwareVersion()).toEqual([0, 0, 0]);
+    expect(device.isBootloader()).toBe(false);
+    expect(device.isInitialized()).toBe(true);
+    expect(device.isSeedless()).toBe(false);
+    expect(device.isUnacquired()).toBe(false);
+    expect(device.hasUsePassphrase()).toBe(true);
+    expect(device.supportInputPinOnSoftware()).toEqual({ support: false });
+    expect(device.supportModifyHomescreen()).toEqual({ support: true });
+    featuresGetter.mockRestore();
+  });
+
+  test('keeps legacy display-name fallbacks separate from the canonical label', () => {
+    const device = Device.fromDescriptor({ id: 'pure', path: 'pure' } as never);
+    device.updateState(
+      {
+        protocol: 'V1',
+        identity: {
+          deviceType: EDeviceType.ClassicPure,
+          label: null,
+          bleName: null,
+        },
+        status: { mode: 'normal', initialized: true },
+      },
+      'initialize'
+    );
+
+    expect(device.getCurrentLabel()).toBeNull();
+    expect(device.getCurrentDisplayName()).toBe('OneKey Classic 1S');
+    expect(device.toMessageObject()).toMatchObject({
+      name: 'OneKey Classic 1S',
+      label: 'OneKey Classic 1S',
+      state: { identity: { label: null } },
+    });
+  });
+
   test('emits only the canonical state event for Protocol V2', () => {
     const device = Device.fromDescriptor({
       id: 'pro2',

package/__tests__/evmLedgerLegacySafety.test.ts

@@ -1,10 +1,11 @@
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
 import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
 import EvmGetAddress from '../src/api/evm/EVMGetAddress';
 import EVMGetPublicKey from '../src/api/evm/EVMGetPublicKey';
 import { findMethod } from '../src/api/utils';
 import { getDeviceType, getFirmwareType, getMethodVersionRange } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
-import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
 
 import type { EDeviceType } from '@onekeyfe/hd-shared';
 
@@ -33,6 +34,7 @@ const createDevice = (onekeyDeviceType: string) => {
       },
       // BaseMethod reads state through Device accessors; reuse production mappers in the stub.
       isProtocolV2: () => false,
+      getProtocol: () => 'V1' as const,
       getCurrentDeviceType: () => getDeviceType(features as any),
       getCurrentSafetyChecks: () => features.safety_checks,
       getCurrentFirmwareType: () => getFirmwareType(features as any),

package/__tests__/firmware-update/check-all-firmware-release.test.ts

@@ -1,4 +1,4 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { ERRORS, EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import CheckAllFirmwareRelease from '../../src/api/CheckAllFirmwareRelease';
 import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
@@ -36,7 +36,40 @@ const mockGetFirmwareReleaseInfo = getFirmwareReleaseInfo as jest.MockedFunction
   typeof getFirmwareReleaseInfo
 >;
 
+const noUpdate = {
+  status: 'valid' as const,
+  release: undefined,
+};
+
+const createMethod = (serialNo = 'device-id') => {
+  const method = new CheckAllFirmwareRelease({
+    id: 1,
+    payload: {
+      method: 'checkAllFirmwareRelease',
+      platform: 'native',
+    },
+  });
+  method.init();
+  method.device = {
+    features: {
+      deviceType: EDeviceType.Classic1s,
+      serialNo,
+      firmwareType: EFirmwareType.Universal,
+      firmwareVersion: '1.0.0',
+      bootloaderVersion: '1.0.0',
+    },
+  } as typeof method.device;
+  return method;
+};
+
 describe('CheckAllFirmwareRelease', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetFirmwareReleaseInfo.mockReturnValue(noUpdate);
+    mockGetBootloaderReleaseInfo.mockReturnValue(noUpdate);
+    mockGetBleFirmwareReleaseInfo.mockReturnValue(noUpdate);
+  });
+
   test('keeps release information available when an optional Plan cannot be built', async () => {
     const firmware = {
       status: 'outdated' as const,
@@ -45,36 +78,14 @@ describe('CheckAllFirmwareRelease', () => {
         version: [3, 0, 0],
       },
     };
-    const noUpdate = {
-      status: 'valid' as const,
-      release: undefined,
-    };
     mockGetFirmwareReleaseInfo.mockReturnValue(firmware);
-    mockGetBootloaderReleaseInfo.mockReturnValue(noUpdate);
-    mockGetBleFirmwareReleaseInfo.mockReturnValue(noUpdate);
     mockBuildFirmwareUpdatePlan.mockImplementation(() => {
-      throw new Error('FirmwarePlanInvalid');
-    });
-
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        platform: 'native',
-      },
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Plan cannot be built', {
+        firmwareUpdateCode: 'FirmwarePlanInvalid',
+      });
     });
-    method.init();
-    method.device = {
-      features: {
-        deviceType: EDeviceType.Classic1s,
-        serialNo: '',
-        firmwareType: EFirmwareType.Universal,
-        firmwareVersion: '1.0.0',
-        bootloaderVersion: '1.0.0',
-      },
-    } as typeof method.device;
 
-    await expect(method.run()).resolves.toEqual(
+    await expect(createMethod('').run()).resolves.toEqual(
       expect.objectContaining({
         firmware,
         bootloader: noUpdate,
@@ -83,4 +94,34 @@ describe('CheckAllFirmwareRelease', () => {
       })
     );
   });
+
+  test('returns an optional Plan when the builder succeeds', async () => {
+    const plan = {
+      schemaVersion: 2 as const,
+      planDigest: 'a'.repeat(64),
+      executor: 'v3' as const,
+      deviceIdentity: 'device-id',
+      deviceModel: EDeviceType.Classic1s,
+      firmwareType: EFirmwareType.Universal,
+      platform: 'native' as const,
+      artifacts: [],
+      targetsToUpdate: [],
+    };
+    mockBuildFirmwareUpdatePlan.mockReturnValue(plan);
+
+    await expect(createMethod().run()).resolves.toEqual(
+      expect.objectContaining({
+        firmwareUpdatePlan: plan,
+      })
+    );
+  });
+
+  test('does not hide unexpected Plan builder failures', async () => {
+    const unexpectedError = new Error('unexpected builder failure');
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw unexpectedError;
+    });
+
+    await expect(createMethod().run()).rejects.toBe(unexpectedError);
+  });
 });

package/__tests__/firmware-update/firmware-update-plan.test.ts

@@ -293,6 +293,34 @@ describe('buildFirmwareUpdatePlan', () => {
     expect(first.planDigest).not.toBe(desktop.planDigest);
   });
 
+  test('normalizes a malformed artifact URL to FirmwarePlanInvalid', () => {
+    let thrown: unknown;
+    try {
+      buildFirmwareUpdatePlan({
+        features: createFeatures({ deviceType: EDeviceType.Classic1s }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'native',
+        firmware: {
+          status: 'outdated',
+          release: {
+            url: 'not a url',
+            version: [3, 0, 0],
+          },
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      });
+    } catch (error) {
+      thrown = error;
+    }
+
+    expect(thrown).toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwarePlanInvalid',
+      },
+    });
+  });
+
   test('binds trusted artifact integrity metadata into the plan digest', () => {
     const createPlan = (fingerprint: string) =>
       buildFirmwareUpdatePlan({

package/__tests__/kaspa-public-types.type-test.ts

@@ -0,0 +1,16 @@
+import type { KaspaSignInputParams, KaspaSignOutputParams } from '../src/types';
+
+const input: KaspaSignInputParams = {
+  path: "m/44'/111111'/0'/0/0",
+  prevTxId: 'aa'.repeat(32),
+  outputIndex: 0,
+  sequenceNumber: 0,
+  output: { satoshis: 200000 },
+};
+
+const output: KaspaSignOutputParams = {
+  satoshis: 100000,
+  address: 'kaspa:example',
+};
+
+export { input, output };