@swapkit/wallet-hardware 4.8.1 → 4.8.2

package/src/keepkey/chains/utxo.ts

@@ -0,0 +1,364 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  FeeOption,
+  type GenericTransferParams,
+  SwapKitError,
+  type UTXOChain,
+} from "@swapkit/helpers";
+import {
+  assertDerivationIndex,
+  createHDWalletHelpers,
+  getNetworkForChain,
+  getUTXOAccountIndexFromPath,
+  getUTXOAccountPath,
+  getUTXOAddressPath,
+  getUtxoApi,
+  stripToCashAddress,
+  type UTXOToolboxes,
+} from "@swapkit/toolboxes/utxo";
+import type { Transaction } from "@swapkit/utxo-signer";
+import { bip32ToAddressNList, ChainToKeepKeyName } from "../coins";
+
+interface KeepKeyInputObject {
+  addressNList: number[];
+  scriptType: string;
+  amount: string;
+  vout: number;
+  txid: string;
+  hex: string;
+}
+
+type KeepKeyUTXOWalletMethods = Record<string, unknown> & { address: string };
+
+export async function utxoWalletMethods({
+  sdk,
+  chain,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  chain: Exclude<UTXOChain, typeof Chain.Zcash>;
+  derivationPath?: DerivationPathArray;
+}): Promise<KeepKeyUTXOWalletMethods> {
+  const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+  // This might not work for BCH
+  const toolbox = await getUtxoToolbox(chain);
+  const scriptType = [Chain.Bitcoin, Chain.Litecoin].includes(chain as typeof Chain.Bitcoin)
+    ? ("p2wpkh" as const)
+    : ("p2pkh" as const);
+
+  const derivationPathString = derivationPath ? derivationPathToString(derivationPath) : `${DerivationPath[chain]}/0`;
+
+  const addressInfo = {
+    address_n: bip32ToAddressNList(derivationPathString),
+    coin: ChainToKeepKeyName[chain],
+    script_type: scriptType,
+  };
+
+  const walletAddress: string = (await sdk.address.utxoGetAddress(addressInfo)).address;
+  const network = getNetworkForChain(chain);
+
+  const signTransaction = async (tx: Transaction, inputs: KeepKeyInputObject[], memo = "") => {
+    const outputs: any[] = [];
+
+    for (let i = 0; i < tx.outputsLength; i++) {
+      const output = tx.getOutput(i);
+      const address = tx.getOutputAddress(i, network);
+      const value = Number(output.amount);
+
+      if (address === walletAddress) {
+        outputs.push({
+          addressNList: addressInfo.address_n,
+          addressType: "change",
+          amount: value,
+          isChange: true,
+          scriptType,
+        });
+      } else if (address) {
+        const outputAddress = chain === Chain.BitcoinCash ? stripToCashAddress(address) : address;
+
+        if (outputAddress) {
+          outputs.push({ address: outputAddress, addressType: "spend", amount: value });
+        }
+      }
+    }
+
+    const removeNullAndEmptyObjectsFromArray = (arr: any[]) => {
+      return arr.filter((item) => item !== null && typeof item === "object" && Object.keys(item).length > 0);
+    };
+
+    const responseSign = await sdk.utxo.utxoSignTransaction({
+      coin: ChainToKeepKeyName[chain],
+      inputs,
+      opReturnData: memo,
+      outputs: removeNullAndEmptyObjectsFromArray(outputs),
+    });
+
+    return responseSign.serializedTx?.toString();
+  };
+
+  const transfer = async ({ recipient, feeOptionKey, feeRate, memo, ...rest }: GenericTransferParams) => {
+    if (!walletAddress)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "From address must be provided" });
+    if (!recipient)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Recipient address must be provided" });
+
+    const createTxMethod =
+      chain === Chain.BitcoinCash
+        ? (toolbox as UTXOToolboxes["BCH"]).buildTx
+        : (toolbox as UTXOToolboxes["BTC"]).createTransaction;
+
+    const { tx, inputs: rawInputs } = await createTxMethod({
+      ...rest,
+      feeRate: feeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast],
+      fetchTxHex: true,
+      memo,
+      recipient,
+      sender: walletAddress,
+    });
+
+    const inputs = rawInputs.map(({ value, index, hash, txHex }) => ({
+      //@TODO don't hardcode master, lookup on blockbook what input this is for and what path that address is!
+      addressNList: addressInfo.address_n,
+      amount: value.toString(),
+      hex: txHex || "",
+      scriptType,
+      txid: hash,
+      vout: index,
+    }));
+
+    const txHex = await signTransaction(tx, inputs, memo);
+    return toolbox.broadcastTx(txHex);
+  };
+
+  const signTransactionWithMultipleInputs = async (
+    tx: Transaction,
+    inputs: Array<{
+      hash: string;
+      index: number;
+      value: number;
+      txHex?: string;
+      derivationIndex: number;
+      isChange: boolean;
+    }>,
+    memo = "",
+  ) => {
+    const accountAddressN = bip32ToAddressNList(
+      derivationPath
+        ? derivationPathToString(derivationPath.slice(0, 3) as DerivationPathArray)
+        : DerivationPath[chain],
+    );
+
+    type KeepKeyOutput =
+      | { addressNList: number[]; addressType: "change"; amount: number; isChange: true; scriptType: string }
+      | { address: string; addressType: "spend"; amount: number };
+
+    const outputs: KeepKeyOutput[] = [];
+    for (let i = 0; i < tx.outputsLength; i++) {
+      const output = tx.getOutput(i);
+      const outputAddress = tx.getOutputAddress(i, network);
+      const value = Number(output.amount);
+
+      if (outputAddress === walletAddress) {
+        outputs.push({
+          addressNList: addressInfo.address_n,
+          addressType: "change",
+          amount: value,
+          isChange: true,
+          scriptType,
+        });
+      } else if (outputAddress) {
+        const finalAddress = chain === Chain.BitcoinCash ? stripToCashAddress(outputAddress) : outputAddress;
+        if (finalAddress) {
+          outputs.push({ address: finalAddress, addressType: "spend", amount: value });
+        }
+      }
+    }
+
+    const keepKeyInputs = inputs.map(({ hash, index: inputIndex, value, txHex, derivationIndex, isChange }) => {
+      const changePath = isChange ? 1 : 0;
+      const inputAddressN = [...accountAddressN, changePath, derivationIndex];
+      return {
+        addressNList: inputAddressN,
+        amount: value.toString(),
+        hex: txHex || "",
+        scriptType,
+        txid: hash,
+        vout: inputIndex,
+      };
+    });
+
+    const responseSign = await sdk.utxo.utxoSignTransaction({
+      coin: ChainToKeepKeyName[chain],
+      inputs: keepKeyInputs,
+      opReturnData: memo,
+      outputs: outputs.filter((item) => item !== null && typeof item === "object" && Object.keys(item).length > 0),
+    });
+
+    return responseSign.serializedTx?.toString() || "";
+  };
+
+  const transferFromMultipleAddresses = async ({
+    utxos,
+    recipient,
+    assetValue,
+    memo,
+    feeRate,
+    feeOptionKey,
+  }: {
+    utxos: Array<{
+      hash: string;
+      index: number;
+      value: number;
+      txHex?: string;
+      derivationIndex: number;
+      isChange: boolean;
+      address: string;
+    }>;
+    recipient: string;
+    assetValue: { getBaseValue: (unit: string) => number; chain: string };
+    memo?: string;
+    feeRate?: number;
+    feeOptionKey?: (typeof FeeOption)[keyof typeof FeeOption];
+  }) => {
+    const txFeeRate = feeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast];
+
+    const createTxMethod =
+      chain === Chain.BitcoinCash
+        ? (toolbox as UTXOToolboxes["BCH"]).buildTx
+        : (toolbox as UTXOToolboxes["BTC"]).createTransaction;
+
+    const { tx, inputs: selectedInputs } = await createTxMethod({
+      assetValue: assetValue as any,
+      feeRate: txFeeRate,
+      fetchTxHex: true,
+      memo,
+      recipient,
+      sender: walletAddress,
+    });
+
+    const inputsWithDerivation = selectedInputs.map(
+      (input: { hash: string; index: number; value: number; txHex?: string }) => {
+        const utxoInfo = utxos.find((u) => u.hash === input.hash && u.index === input.index);
+        return { ...input, derivationIndex: utxoInfo?.derivationIndex ?? 0, isChange: utxoInfo?.isChange ?? false };
+      },
+    );
+
+    const signedTxHex = await signTransactionWithMultipleInputs(tx, inputsWithDerivation, memo);
+    return toolbox.broadcastTx(signedTxHex);
+  };
+
+  async function getExtendedPublicKeyInfo({ accountIndex }: { accountIndex?: number } = {}) {
+    try {
+      const resolvedAccountPath = getUTXOAccountPath({ accountIndex, chain, derivationPath });
+      const resolvedAccountPathString = derivationPathToString(resolvedAccountPath);
+      const path = {
+        address_n: bip32ToAddressNList(resolvedAccountPathString),
+        coin: ChainToKeepKeyName[chain],
+        script_type: scriptType,
+        showDisplay: false,
+        symbol: chain.toUpperCase(),
+      };
+
+      const responsePubkey = await sdk.system.info.getPublicKey(path);
+
+      return {
+        accountIndex: getUTXOAccountIndexFromPath(resolvedAccountPath),
+        path: resolvedAccountPathString,
+        xpub: responsePubkey.xpub,
+      };
+    } catch (error) {
+      throw new SwapKitError("wallet_keepkey_failed_to_get_public_key", {
+        chain,
+        error: error instanceof Error ? error.message : "Unknown error",
+      });
+    }
+  }
+
+  function getExtendedPublicKey() {
+    return getExtendedPublicKeyInfo();
+  }
+
+  async function deriveAddressAtIndex({
+    accountIndex,
+    index,
+    change = false,
+  }: {
+    accountIndex?: number;
+    index: number;
+    change?: boolean;
+  }) {
+    try {
+      assertDerivationIndex("index", index);
+      const fullPath = getUTXOAddressPath({ accountIndex, chain, change, derivationPath, index });
+      const fullPathString = derivationPathToString(fullPath);
+
+      const result = await sdk.address.utxoGetAddress({
+        address_n: bip32ToAddressNList(fullPathString),
+        coin: ChainToKeepKeyName[chain],
+        script_type: scriptType,
+      });
+
+      let finalAddress = result.address;
+      if (chain === Chain.BitcoinCash) {
+        finalAddress = stripToCashAddress(result.address);
+      }
+
+      return {
+        accountIndex: getUTXOAccountIndexFromPath(fullPath),
+        address: finalAddress,
+        change,
+        index,
+        path: fullPathString,
+        pubkey: "",
+      };
+    } catch {
+      return undefined;
+    }
+  }
+
+  async function deriveAddresses({
+    accountIndex,
+    count,
+    startIndex = 0,
+    change = false,
+  }: {
+    accountIndex?: number;
+    count: number;
+    startIndex?: number;
+    change?: boolean;
+  }) {
+    assertDerivationIndex("count", count);
+    assertDerivationIndex("startIndex", startIndex);
+
+    const addresses = await Promise.all(
+      Array.from({ length: count }, (_, i) => deriveAddressAtIndex({ accountIndex, change, index: startIndex + i })),
+    );
+
+    return addresses.filter((address) => !!address);
+  }
+
+  const hdHelpers = createHDWalletHelpers({
+    chain,
+    deriveAddress: deriveAddressAtIndex,
+    getBalance: toolbox.getBalance,
+    getUtxos: (address: string) => getUtxoApi(chain).getUtxos({ address, fetchTxHex: true }),
+  });
+
+  return {
+    ...toolbox,
+    ...hdHelpers,
+    address: walletAddress,
+    deriveAddressAtIndex,
+    deriveAddresses,
+    getExtendedPublicKey,
+    getExtendedPublicKeyInfo,
+    signTransaction,
+    signTransactionWithMultipleInputs,
+    transfer,
+    transferFromMultipleAddresses,
+  };
+}

package/src/keepkey/coins.ts

@@ -0,0 +1,67 @@
+/*
+    KeepKey Specific bip32 path conventions
+*/
+
+import { SwapKitError } from "@swapkit/helpers";
+
+const HARDENED = 0x80000000;
+
+export enum ChainToKeepKeyName {
+  BTC = "Bitcoin",
+  BCH = "BitcoinCash",
+  DOGE = "Dogecoin",
+  LTC = "Litecoin",
+  DASH = "Dash",
+  XRP = "Ripple",
+}
+
+export function addressNListToBIP32(address: number[]) {
+  return `m/${address.map((num) => (num >= HARDENED ? `${num - HARDENED}'` : num)).join("/")}`;
+}
+
+export function bip32Like(path: string) {
+  if (path === "m/") return true;
+
+  return /^m(((\/[0-9]+h)+|(\/[0-9]+H)+|(\/[0-9]+')*)((\/[0-9]+)*))$/.test(path);
+}
+
+export function bip32ToAddressNList(initPath: string): number[] {
+  let path = initPath;
+
+  if (!bip32Like(path)) {
+    throw new SwapKitError("wallet_keepkey_invalid_params", { reason: `Not a bip32 path: '${path}'` });
+  }
+
+  if (/^m\//i.test(path)) {
+    path = path.slice(2);
+  }
+  const segments = path.split("/");
+
+  if (segments.length === 1 && segments[0] === "") return [];
+
+  const ret = new Array(segments.length);
+
+  for (let i = 0; i < segments.length; i++) {
+    // TODO: Check for better way instead of exec
+    const segment = segments[i];
+    if (segment) {
+      const tmp = /(\d+)([hH']?)/.exec(segment);
+      if (tmp === null) throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid input" });
+
+      const [, num = "", modifier = ""] = tmp;
+
+      ret[i] = Number.parseInt(num, 10);
+
+      if (ret[i] >= HARDENED)
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid child index" });
+
+      if (modifier === "h" || modifier === "H" || modifier === "'") {
+        ret[i] += HARDENED;
+      } else if (modifier.length > 0) {
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid modifier" });
+      }
+    }
+  }
+
+  return ret;
+}

package/src/keepkey/index.ts

@@ -0,0 +1,174 @@
+import { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  Chain,
+  type DerivationPathArray,
+  filterSupportedChains,
+  NetworkDerivationPath,
+  SKConfig,
+  SwapKitError,
+  WalletOption,
+} from "@swapkit/helpers";
+
+export type { PairingInfo } from "@keepkey/keepkey-sdk";
+
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+import { cosmosWalletMethods } from "./chains/cosmos";
+import { KeepKeySigner } from "./chains/evm";
+import { mayachainWalletMethods } from "./chains/mayachain";
+import { thorchainWalletMethods } from "./chains/thorchain";
+import { utxoWalletMethods } from "./chains/utxo";
+
+export const keepkeyWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectKeepkey(chains: Chain[], derivationPathMap?: Record<Chain, DerivationPathArray>) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+      const pairingInfo = SKConfig.get("integrations").keepKey;
+      if (!pairingInfo) throw new Error("KeepKey config not found");
+
+      const initialApiKey = SKConfig.get("apiKeys").keepKey || "1234";
+
+      await checkAndLaunch();
+
+      // Conform to the expected { apiKey, pairingInfo } structure
+      const keepkeyConfig = { apiKey: initialApiKey, pairingInfo };
+      const keepKeySdk = await KeepKeySdk.create(keepkeyConfig);
+
+      // Persist the new API key via SKConfig after pairing
+      if (keepkeyConfig.apiKey && keepkeyConfig.apiKey !== initialApiKey) {
+        SKConfig.setApiKey("keepKey", keepkeyConfig.apiKey);
+      }
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const walletMethods = await getWalletMethods({
+            chain,
+            derivationPath: derivationPathMap?.[chain] || NetworkDerivationPath[chain],
+            sdk: keepKeySdk,
+          });
+          const address = (await walletMethods.getAddress()) || "";
+
+          addChain({ ...walletMethods, address, chain, walletType: WalletOption.KEEPKEY });
+        }),
+      );
+      return true;
+    },
+  directSigningSupport: {
+    [Chain.Arbitrum]: true,
+    [Chain.Avalanche]: true,
+    [Chain.Base]: true,
+    [Chain.Berachain]: true,
+    [Chain.BinanceSmartChain]: true,
+    [Chain.Ethereum]: true,
+    [Chain.Gnosis]: true,
+    [Chain.Monad]: true,
+    [Chain.Optimism]: true,
+    [Chain.Polygon]: true,
+    [Chain.Ripple]: true,
+    [Chain.XLayer]: true,
+    // BTC/BCH/DASH/DOGE/LTC/Cosmos/THORChain/Maya: pending KeepKey SDK signer wrappers (V3 plan PRs)
+  },
+  name: "connectKeepkey",
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.Berachain,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.BitcoinCash,
+    Chain.Cosmos,
+    Chain.Dogecoin,
+    Chain.Dash,
+    Chain.Ethereum,
+    Chain.Gnosis,
+    Chain.Litecoin,
+    Chain.Monad,
+    Chain.Ripple,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.THORChain,
+    Chain.Maya,
+    Chain.XLayer,
+  ],
+  walletType: WalletOption.KEEPKEY,
+});
+
+export const KEEPKEY_SUPPORTED_CHAINS = getWalletSupportedChains(keepkeyWallet);
+
+async function getWalletMethods({
+  sdk,
+  chain,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  chain: Chain;
+  derivationPath?: DerivationPathArray;
+}) {
+  const { getProvider, getEvmToolboxAsync } = await import("@swapkit/toolboxes/evm");
+
+  switch (chain) {
+    case Chain.BinanceSmartChain:
+    case Chain.Arbitrum:
+    case Chain.Berachain:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.Avalanche:
+    case Chain.Base:
+    case Chain.Ethereum:
+    case Chain.Gnosis:
+    case Chain.Monad:
+    case Chain.XLayer: {
+      const provider = await getProvider(chain);
+      const signer = new KeepKeySigner({ chain, derivationPath, provider, sdk });
+      const toolbox = await getEvmToolboxAsync(chain, { provider, signer });
+
+      return toolbox;
+    }
+    case Chain.Cosmos: {
+      return cosmosWalletMethods({ derivationPath, sdk });
+    }
+    case Chain.THORChain: {
+      return thorchainWalletMethods({ derivationPath, sdk });
+    }
+    case Chain.Maya: {
+      return mayachainWalletMethods({ derivationPath, sdk });
+    }
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dash:
+    case Chain.Dogecoin:
+    case Chain.Litecoin: {
+      return utxoWalletMethods({ chain, derivationPath, sdk });
+    }
+    case Chain.Ripple: {
+      const { rippleWalletMethods } = await import("./chains/ripple");
+      return rippleWalletMethods({ derivationPath, sdk });
+    }
+    default:
+      throw new SwapKitError("wallet_keepkey_chain_not_supported", { chain });
+  }
+}
+
+// kk-sdk docs: https://keepkey.com/blog/building_on_the_keepkey_sdk
+// test spec: if offline, launch keepkey-bridge
+async function checkAndLaunch(attempts = 0) {
+  if (attempts >= 3) {
+    alert("KeepKey desktop is required for keepkey-sdk, please go to https://keepkey.com/get-started");
+  }
+  const isAvailable = await checkKeepkeyAvailability();
+
+  if (!isAvailable) {
+    window.location.assign("keepkey://launch");
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+    await checkAndLaunch(attempts + 1);
+  }
+}
+
+async function checkKeepkeyAvailability(spec = "http://localhost:1646/spec/swagger.json") {
+  try {
+    const response = await fetch(spec);
+    return response.status === 200;
+  } catch {
+    return false;
+  }
+}

package/src/ledger/clients/cosmos.ts

@@ -0,0 +1,84 @@
+import {
+  type DerivationPathArray,
+  derivationPathToString,
+  NetworkDerivationPath,
+  SwapKitError,
+} from "@swapkit/helpers";
+import { CosmosLedgerInterface } from "../interfaces/CosmosLedgerInterface";
+
+export class CosmosLedger extends CosmosLedgerInterface {
+  private pubKey: string | null = null;
+
+  derivationPath: string;
+
+  constructor(derivationPath: DerivationPathArray = NetworkDerivationPath.GAIA) {
+    super();
+    this.chain = "cosmos";
+    this.derivationPath = derivationPathToString(derivationPath);
+  }
+
+  connect = async () => {
+    await this.checkOrCreateTransportAndLedger(true);
+    const { publicKey, address } = await this.getAddressAndPubKey();
+
+    this.pubKey = Buffer.from(publicKey, "hex").toString("base64");
+
+    return address;
+  };
+
+  getAddressAndPubKey = async () => {
+    await this.checkOrCreateTransportAndLedger(true);
+
+    const response = await this.ledgerApp.getAddress(this.derivationPath, this.chain);
+
+    return response;
+  };
+
+  signTransaction = async (rawTx: string, sequence = "0") => {
+    await this.checkOrCreateTransportAndLedger(true);
+
+    const { return_code, error_message, signature } = await this.ledgerApp.sign(this.derivationPath, rawTx);
+
+    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
+
+    this.validateResponse(return_code, error_message);
+
+    return [{ pub_key: { type: "tendermint/PubKeySecp256k1", value: this.pubKey }, sequence, signature }];
+  };
+
+  signAmino = async (signerAddress: string, signDoc: any): Promise<any> => {
+    await this.checkOrCreateTransportAndLedger(true);
+
+    const accounts = await this.getAccounts();
+    const accountIndex = accounts.findIndex((account) => account.address === signerAddress);
+
+    if (accountIndex === -1) {
+      throw new SwapKitError("wallet_ledger_address_not_found", { address: signerAddress });
+    }
+
+    const importedAmino = await import("@cosmjs/amino");
+    const encodeSecp256k1Signature =
+      importedAmino.encodeSecp256k1Signature ?? importedAmino.default?.encodeSecp256k1Signature;
+    const serializeSignDoc = importedAmino.serializeSignDoc ?? importedAmino.default?.serializeSignDoc;
+    const importedCrypto = await import("@cosmjs/crypto");
+    const Secp256k1Signature = importedCrypto.Secp256k1Signature ?? importedCrypto.default?.Secp256k1Signature;
+
+    const message = serializeSignDoc(signDoc);
+    const signature = await this.ledgerApp.sign(this.derivationPath, message);
+
+    this.validateResponse(signature.return_code, signature.error_message);
+
+    const secpSignature = Secp256k1Signature.fromDer(signature.signature).toFixedLength();
+
+    return { signature: encodeSecp256k1Signature(accounts[0].pubkey, secpSignature), signed: signDoc };
+  };
+
+  getAccounts = async () => {
+    await this.checkOrCreateTransportAndLedger(true);
+
+    const addressAndPubKey = await this.getAddressAndPubKey();
+    return [
+      { address: addressAndPubKey.address, algo: "secp256k1", pubkey: Buffer.from(addressAndPubKey.publicKey, "hex") },
+    ] as any[];
+  };
+}