@onekeyfe/hardware-cli 1.1.25-alpha.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "onekey-hardware",
+  "description": "OneKey hardware wallet CLI skills for Claude Code — device management, multi-chain signing, firmware updates",
+  "version": "0.1.0",
+  "author": {
+    "name": "OneKey",
+    "email": "dev@onekey.so"
+  },
+  "homepage": "https://onekey.so",
+  "repository": "https://github.com/OneKeyHQ/hardware-js-sdk",
+  "license": "Apache-2.0",
+  "keywords": ["hardware-wallet", "signing", "bitcoin", "ethereum", "onekey", "security"],
+  "skills": "./skills/"
+}

package/dist/chains.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Chain Resolver — maps chain identifiers to the correct SDK API calls.
+ * Handles derivation path defaults and chain-specific parameter transformations.
+ *
+ * Reference: developer-portal docs at
+ *   content/en/hardware-sdk/chains/<chain>/<method>.mdx
+ *   content/en/hardware-sdk/core-api-guide.mdx (HD path section)
+ *
+ * Type definitions: packages/core/src/types/api/*.ts
+ */
+import type { CoreApi } from '@onekeyfe/hd-core';
+/**
+ * Common params passed to all SDK methods.
+ * Reference: packages/core/src/types/api/export.ts (CommonParams)
+ */
+export interface CommonCLIParams {
+    connectId?: string;
+    deviceId?: string;
+    passphraseState?: string;
+    useEmptyPassphrase?: boolean;
+}
+export interface GetAddressParams extends CommonCLIParams {
+    chain: string;
+    path?: string;
+    showOnDevice?: boolean;
+}
+export declare function resolveGetAddress(sdk: CoreApi, params: GetAddressParams): Promise<{
+    success: boolean;
+    error: string;
+    chain: string;
+    path: string;
+} | {
+    chain: string;
+    path: string;
+    success?: undefined;
+    error?: undefined;
+}>;
+export interface GetPublicKeyParams extends CommonCLIParams {
+    chain: string;
+    path?: string;
+}
+export declare function resolveGetPublicKey(sdk: CoreApi, params: GetPublicKeyParams): Promise<{
+    chain: string;
+    path: string;
+}>;
+export interface SignTransactionParams extends CommonCLIParams {
+    chain: string;
+    path?: string;
+    transaction: Record<string, unknown>;
+}
+export declare function resolveSignTransaction(sdk: CoreApi, params: SignTransactionParams): Promise<{
+    chain: string;
+    path: string;
+}>;
+export interface SignMessageParams extends CommonCLIParams {
+    chain: string;
+    path?: string;
+    message: string;
+}
+export declare function resolveSignMessage(sdk: CoreApi, params: SignMessageParams): Promise<{
+    chain: string;
+    path: string;
+}>;
+export interface BatchGetAddressParams extends CommonCLIParams {
+    bundle: Array<{
+        chain: string;
+        path?: string;
+        showOnDevice?: boolean;
+    }>;
+}
+export declare function resolveBatchGetAddress(sdk: CoreApi, params: BatchGetAddressParams): Promise<{
+    success: boolean;
+    addresses: Record<string, unknown>[];
+}>;

package/dist/chains.js

@@ -0,0 +1,307 @@
+'use strict';
+
+/**
+ * Chain Resolver — maps chain identifiers to the correct SDK API calls.
+ * Handles derivation path defaults and chain-specific parameter transformations.
+ *
+ * Reference: developer-portal docs at
+ *   content/en/hardware-sdk/chains/<chain>/<method>.mdx
+ *   content/en/hardware-sdk/core-api-guide.mdx (HD path section)
+ *
+ * Type definitions: packages/core/src/types/api/*.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBatchGetAddress = exports.resolveSignMessage = exports.resolveSignTransaction = exports.resolveGetPublicKey = exports.resolveGetAddress = void 0;
+// Default BIP44 derivation paths per chain
+// Sources: developer-portal core-api-guide.mdx + chain-specific docs
+const DEFAULT_PATHS = {
+    evm: "m/44'/60'/0'/0/0",
+    btc: "m/84'/0'/0'/0/0",
+    sol: "m/44'/501'/0'/0'",
+    tron: "m/44'/195'/0'/0/0",
+    cosmos: "m/44'/118'/0'/0/0",
+    cardano: "m/1852'/1815'/0'/0/0",
+    polkadot: "m/44'/354'/0'/0'/0'",
+    aptos: "m/44'/637'/0'/0'/0'",
+    sui: "m/44'/784'/0'/0'/0'",
+    near: "m/44'/397'/0'",
+    xrp: "m/44'/144'/0'/0/0",
+    stellar: "m/44'/148'/0'",
+    ton: "m/44'/607'/0'",
+    nostr: "m/44'/1237'/0'/0/0",
+    filecoin: "m/44'/461'/0'/0/0",
+    kaspa: "m/44'/111111'/0'/0/0",
+    algo: "m/44'/283'/0'/0/0",
+    conflux: "m/44'/503'/0'/0/0",
+    nervos: "m/44'/309'/0'/0/0",
+    alephium: "m/44'/1234'/0'/0/0",
+    neo: "m/44'/888'/0'/0/0",
+    starcoin: "m/44'/101010'/0'/0'/0'",
+    nem: "m/44'/43'/0'/0'/0'",
+    dnx: "m/44'/29538'/0'/0'/0'",
+    scdo: "m/44'/541'/0'/0/0",
+    benfen: "m/44'/728'/0'/0'/0'",
+    nexa: "m/44'/29223'/0'/0/0",
+};
+// Chain name aliases for fuzzy matching
+const CHAIN_ALIASES = {
+    ethereum: 'evm',
+    eth: 'evm',
+    bitcoin: 'btc',
+    solana: 'sol',
+    dot: 'polkadot',
+    ada: 'cardano',
+    atom: 'cosmos',
+    apt: 'aptos',
+    ripple: 'xrp',
+    xlm: 'stellar',
+    fil: 'filecoin',
+    ckb: 'nervos',
+    alph: 'alephium',
+    cfx: 'conflux',
+    stc: 'starcoin',
+    xem: 'nem',
+    bfc: 'benfen',
+};
+function resolveChain(chain) {
+    const normalized = chain.toLowerCase().trim();
+    return CHAIN_ALIASES[normalized] || normalized;
+}
+function getDefaultPath(chain) {
+    const resolved = resolveChain(chain);
+    const path = DEFAULT_PATHS[resolved];
+    if (!path) {
+        throw new Error(`Unsupported chain: ${chain}. Supported: ${Object.keys(DEFAULT_PATHS).join(', ')}`);
+    }
+    return path;
+}
+async function resolveGetAddress(sdk, params) {
+    const chain = resolveChain(params.chain);
+    const path = params.path || getDefaultPath(chain);
+    const showOnOneKey = params.showOnDevice ?? true;
+    const connectId = params.connectId || '';
+    const deviceId = params.deviceId || '';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const chainMethodMap = {
+        evm: () => sdk.evmGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        btc: () => sdk.btcGetAddress(connectId, deviceId, { path, showOnOneKey, coin: 'btc' }),
+        sol: () => sdk.solGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        tron: () => sdk.tronGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        cosmos: () => sdk.cosmosGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        // Cardano requires networkId, protocolMagic, derivationType
+        cardano: () => sdk.cardanoGetAddress(connectId, deviceId, {
+            addressParameters: { path, addressType: 0 },
+            networkId: 1,
+            protocolMagic: 764824073,
+            derivationType: 1,
+            showOnOneKey,
+        }),
+        // Polkadot requires network param
+        polkadot: () => sdk.polkadotGetAddress(connectId, deviceId, {
+            path,
+            prefix: 0,
+            network: 'polkadot',
+            showOnOneKey,
+        }),
+        aptos: () => sdk.aptosGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        sui: () => sdk.suiGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        near: () => sdk.nearGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        xrp: () => sdk.xrpGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        stellar: () => sdk.stellarGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        ton: () => sdk.tonGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        filecoin: () => sdk.filecoinGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        kaspa: () => sdk.kaspaGetAddress(connectId, deviceId, { path, showOnOneKey, prefix: 'kaspa' }),
+        algo: () => sdk.algoGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        conflux: () => sdk.confluxGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        nervos: () => sdk.nervosGetAddress(connectId, deviceId, { path, showOnOneKey, network: 'ckb' }),
+        alephium: () => sdk.alephiumGetAddress(connectId, deviceId, { path, showOnOneKey, group: 0 }),
+        neo: () => sdk.neoGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        starcoin: () => sdk.starcoinGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        nem: () => sdk.nemGetAddress(connectId, deviceId, { path, showOnOneKey, network: 104 }),
+        dnx: () => sdk.dnxGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        scdo: () => sdk.scdoGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        benfen: () => sdk.benfenGetAddress(connectId, deviceId, { path, showOnOneKey }),
+        nexa: () => sdk.nexaGetAddress(connectId, deviceId, { path, showOnOneKey, prefix: 'nexa' }),
+    };
+    const method = chainMethodMap[chain];
+    if (!method) {
+        throw new Error(`getAddress not supported for chain: ${chain}`);
+    }
+    const result = await method();
+    if (result == null) {
+        return { success: false, error: 'No response from device', chain, path };
+    }
+    return { ...result, chain, path };
+}
+exports.resolveGetAddress = resolveGetAddress;
+async function resolveGetPublicKey(sdk, params) {
+    const chain = resolveChain(params.chain);
+    const path = params.path || getDefaultPath(chain);
+    const connectId = params.connectId || '';
+    const deviceId = params.deviceId || '';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const chainMethodMap = {
+        evm: () => sdk.evmGetPublicKey(connectId, deviceId, { path }),
+        btc: () => sdk.btcGetPublicKey(connectId, deviceId, { path, coin: 'btc' }),
+        aptos: () => sdk.aptosGetPublicKey(connectId, deviceId, { path }),
+        cosmos: () => sdk.cosmosGetPublicKey(connectId, deviceId, { path }),
+        sui: () => sdk.suiGetPublicKey(connectId, deviceId, { path }),
+        starcoin: () => sdk.starcoinGetPublicKey(connectId, deviceId, { path }),
+        nostr: () => sdk.nostrGetPublicKey(connectId, deviceId, { path }),
+        benfen: () => sdk.benfenGetPublicKey(connectId, deviceId, { path }),
+        cardano: () => sdk.cardanoGetPublicKey(connectId, deviceId, { path, derivationType: 1 }),
+    };
+    const method = chainMethodMap[chain];
+    if (!method) {
+        throw new Error(`getPublicKey not supported for chain: ${chain}. Supported: ${Object.keys(chainMethodMap).join(', ')}`);
+    }
+    const result = await method();
+    return { ...result, chain, path };
+}
+exports.resolveGetPublicKey = resolveGetPublicKey;
+async function resolveSignTransaction(sdk, params) {
+    const chain = resolveChain(params.chain);
+    const path = params.path || getDefaultPath(chain);
+    const connectId = params.connectId || '';
+    const deviceId = params.deviceId || '';
+    const tx = params.transaction;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const chainMethodMap = {
+        // EVM: chainId is inside the transaction object, not top-level
+        evm: () => sdk.evmSignTransaction(connectId, deviceId, { path, transaction: tx }),
+        // BTC: requires inputs/outputs/refTxs/coin format
+        btc: () => sdk.btcSignTransaction(connectId, deviceId, { coin: 'btc', ...tx }),
+        sol: () => sdk.solSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        tron: () => sdk.tronSignTransaction(connectId, deviceId, { path, transaction: tx }),
+        cosmos: () => sdk.cosmosSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        aptos: () => sdk.aptosSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        sui: () => sdk.suiSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        near: () => sdk.nearSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        // XRP: implementation reads path + transaction from payload despite type declaration
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        xrp: () => sdk.xrpSignTransaction(connectId, deviceId, {
+            path,
+            transaction: tx,
+        }),
+        stellar: () => sdk.stellarSignTransaction(connectId, deviceId, {
+            path,
+            networkPassphrase: tx.networkPassphrase,
+            transaction: tx.transaction,
+        }),
+        // Polkadot: requires prefix param
+        polkadot: () => sdk.polkadotSignTransaction(connectId, deviceId, {
+            path,
+            rawTx: tx.rawTx,
+            network: tx.network || 'polkadot',
+            prefix: tx.prefix ?? 0,
+        }),
+        filecoin: () => sdk.filecoinSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        kaspa: () => sdk.kaspaSignTransaction(connectId, deviceId, { ...tx }),
+        algo: () => sdk.algoSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        conflux: () => sdk.confluxSignTransaction(connectId, deviceId, { path, transaction: tx }),
+        nervos: () => sdk.nervosSignTransaction(connectId, deviceId, { ...tx }),
+        alephium: () => sdk.alephiumSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        neo: () => sdk.neoSignTransaction(connectId, deviceId, { path, ...tx }),
+        dnx: () => sdk.dnxSignTransaction(connectId, deviceId, { path, ...tx }),
+        // SCDO: flat params (nonce, gasPrice, gasLimit, to, value, data), not wrapped
+        scdo: () => sdk.scdoSignTransaction(connectId, deviceId, { path, ...tx }),
+        benfen: () => sdk.benfenSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+        nexa: () => sdk.nexaSignTransaction(connectId, deviceId, { ...tx }),
+        cardano: () => sdk.cardanoSignTransaction(connectId, deviceId, { ...tx }),
+        starcoin: () => sdk.starcoinSignTransaction(connectId, deviceId, { path, rawTx: tx.rawTx }),
+    };
+    const method = chainMethodMap[chain];
+    if (!method) {
+        throw new Error(`signTransaction not supported for chain: ${chain}`);
+    }
+    const result = await method();
+    return { ...result, chain, path };
+}
+exports.resolveSignTransaction = resolveSignTransaction;
+async function resolveSignMessage(sdk, params) {
+    const chain = resolveChain(params.chain);
+    const path = params.path || getDefaultPath(chain);
+    const connectId = params.connectId || '';
+    const deviceId = params.deviceId || '';
+    // Most chains use `messageHex` (hex-encoded). CLI accepts either:
+    // - Already hex-encoded string (starts with "0x" or matches /^[0-9a-fA-F]+$/)
+    // - Plain text string (auto-converted to hex)
+    const raw = params.message;
+    const isHex = /^(0x)?[0-9a-fA-F]+$/.test(raw);
+    const msg = isHex ? raw.replace(/^0x/, '') : Buffer.from(raw, 'utf8').toString('hex');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const chainMethodMap = {
+        evm: () => sdk.evmSignMessage(connectId, deviceId, { path, messageHex: msg }),
+        // BTC: uses messageHex, not message
+        btc: () => sdk.btcSignMessage(connectId, deviceId, { path, messageHex: msg, coin: 'btc' }),
+        sol: () => sdk.solSignMessage(connectId, deviceId, { path, messageHex: msg }),
+        // Tron: uses messageHex
+        tron: () => sdk.tronSignMessage(connectId, deviceId, { path, messageHex: msg }),
+        aptos: () => sdk.aptosSignMessage(connectId, deviceId, { path, payload: { message: msg } }),
+        sui: () => sdk.suiSignMessage(connectId, deviceId, { path, messageHex: msg }),
+        // Conflux: uses messageHex
+        conflux: () => sdk.confluxSignMessage(connectId, deviceId, { path, messageHex: msg }),
+        // Starcoin: uses messageHex
+        starcoin: () => sdk.starcoinSignMessage(connectId, deviceId, { path, messageHex: msg }),
+        // TON: tonSignMessage is transfer-signing, pass JSON params
+        ton: () => {
+            const tonParams = JSON.parse(msg);
+            return sdk.tonSignMessage(connectId, deviceId, { path, ...tonParams });
+        },
+        // Nostr: event must be a NostrEvent object (kind, content, tags, created_at)
+        nostr: () => {
+            const event = JSON.parse(msg);
+            return sdk.nostrSignEvent(connectId, deviceId, { path, event });
+        },
+        // SCDO: uses messageHex
+        scdo: () => sdk.scdoSignMessage(connectId, deviceId, { path, messageHex: msg }),
+        // Alephium: requires messageType
+        alephium: () => sdk.alephiumSignMessage(connectId, deviceId, {
+            path,
+            messageHex: msg,
+            messageType: 'alephium',
+        }),
+        benfen: () => sdk.benfenSignMessage(connectId, deviceId, { path, messageHex: msg }),
+        // Cardano: uses `message` field, requires networkId
+        cardano: () => sdk.cardanoSignMessage(connectId, deviceId, {
+            path,
+            message: msg,
+            derivationType: 1,
+            networkId: 1,
+        }),
+    };
+    const method = chainMethodMap[chain];
+    if (!method) {
+        throw new Error(`signMessage not supported for chain: ${chain}. Supported: ${Object.keys(chainMethodMap).join(', ')}`);
+    }
+    const result = await method();
+    return { ...result, chain, path };
+}
+exports.resolveSignMessage = resolveSignMessage;
+async function resolveBatchGetAddress(sdk, params) {
+    // #13 FIX: Collect per-item results with error handling for partial failures
+    const results = [];
+    for (const item of params.bundle) {
+        try {
+            const result = await resolveGetAddress(sdk, {
+                chain: item.chain,
+                path: item.path,
+                showOnDevice: item.showOnDevice ?? false,
+                connectId: params.connectId,
+                deviceId: params.deviceId,
+            });
+            results.push(result);
+        }
+        catch (err) {
+            results.push({
+                chain: item.chain,
+                path: item.path,
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    const allSuccess = results.every(r => r.success !== false);
+    return { success: allSuccess, addresses: results };
+}
+exports.resolveBatchGetAddress = resolveBatchGetAddress;

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};