@swapkit/wallet-hardware 4.2.10 → 4.6.0

package/src/keepkey/chains/ripple.ts

@@ -1,88 +0,0 @@
-import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
-import {
-  Chain,
-  DerivationPath,
-  type DerivationPathArray,
-  derivationPathToString,
-  type GenericTransferParams,
-} from "@swapkit/helpers";
-import { getRippleToolbox } from "@swapkit/toolboxes/ripple";
-import { bip32ToAddressNList } from "../coins";
-
-export const rippleWalletMethods = async ({
-  sdk,
-  derivationPath,
-}: {
-  sdk: KeepKeySdk;
-  derivationPath?: DerivationPathArray;
-}) => {
-  // Derivation path handling (default to standard XRP 44'/144'/0'/0/0)
-  const derivationPathString = derivationPath
-    ? derivationPathToString(derivationPath)
-    : `${DerivationPath[Chain.Ripple]}/0`;
-
-  // Fetch address from KeepKey
-  const { address } = await (sdk as any).address.xrpGetAddress({
-    address_n: bip32ToAddressNList(derivationPathString),
-  });
-
-  // Inject minimal signer so toolbox's address helpers work
-  const signer = {
-    getAddress: () => Promise.resolve(address),
-    signTransaction: () => {
-      throw new Error("signTransaction not supported via toolbox");
-    },
-  };
-
-  const toolbox = await getRippleToolbox({ signer });
-
-  const transfer = async ({ recipient, assetValue, memo }: GenericTransferParams) => {
-    // Build XRPL Payment tx using toolbox helper
-    const tx = await toolbox.createTransaction({ assetValue, memo, recipient, sender: address });
-
-    // Convert toolbox Payment tx into KeepKey StdTx wrapper (KeepKey-specific format)
-    const stdTx = {
-      type: "auth/StdTx",
-      value: {
-        fee: { amount: [{ amount: "1000", denom: "drop" }], gas: "28000" },
-        memo: memo && memo.length > 0 ? memo : "",
-        msg: [
-          {
-            type: "ripple-sdk/MsgSend",
-            value: { amount: [{ amount: tx.Amount, denom: "drop" }], from_address: address, to_address: recipient },
-          },
-        ],
-        signatures: null,
-      },
-    };
-
-    const unsignedTx = {
-      addressNList: bip32ToAddressNList(derivationPathString),
-      flags: tx.Flags === 0 ? undefined : tx.Flags,
-      lastLedgerSequence: tx.LastLedgerSequence?.toString(),
-      payment: {
-        amount: tx.Amount,
-        destination: tx.Destination,
-        destinationTag: (tx.DestinationTag ?? "0").toString(),
-      },
-      sequence: (tx.Sequence ?? 0).toString(),
-      tx: stdTx,
-    } as any;
-
-    // Sign with KeepKey
-    const responseSign = JSON.parse(await (sdk as any).xrp.xrpSignTransaction(unsignedTx));
-
-    // keepkey-sdk may return either { tx_blob } or StdTx with Base64 serializedTx
-    const txBlob: string | undefined =
-      (responseSign as any).tx_blob ?? (responseSign as any).value?.signatures?.[0]?.serializedTx;
-    if (!txBlob) throw new Error("KeepKey XRP sign failed");
-
-    const buffer = Buffer.from(txBlob, "base64");
-    const txBlobHex = buffer.toString("hex");
-
-    // Broadcast signed tx via toolbox
-    return toolbox.broadcastTransaction(txBlobHex);
-  };
-
-  return { ...toolbox, address, getAddress: () => address, transfer };
-};

package/src/keepkey/chains/thorchain.ts

@@ -1,93 +0,0 @@
-import type { KeepKeySdk, TypesThorchainSignDocDeposit, TypesThorchainSignDocTransfer } from "@keepkey/keepkey-sdk";
-import {
-  type AssetValue,
-  Chain,
-  DerivationPath,
-  type DerivationPathArray,
-  derivationPathToString,
-  type GenericTransferParams,
-  getRPCUrl,
-  SwapKitError,
-  THORConfig,
-} from "@swapkit/helpers";
-import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
-
-import { bip32ToAddressNList } from "../coins";
-
-type SignTransactionParams = { assetValue: AssetValue; recipient?: string; sender: string; memo: string | undefined };
-
-export async function thorchainWalletMethods({
-  sdk,
-  derivationPath,
-}: {
-  sdk: KeepKeySdk;
-  derivationPath?: DerivationPathArray;
-}): Promise<any> {
-  const importedAmino = await import("@cosmjs/amino");
-  const makeSignDoc = importedAmino.makeSignDoc ?? importedAmino.default?.makeSignDoc;
-  const { buildAminoMsg, getDefaultChainFee, createStargateClient, getCosmosToolbox } = await import(
-    "@swapkit/toolboxes/cosmos"
-  );
-
-  const toolbox = await getCosmosToolbox(Chain.THORChain);
-  const derivationPathString = derivationPath ? derivationPathToString(derivationPath) : `${DerivationPath.THOR}/0`;
-
-  const { address: fromAddress } = (await sdk.address.thorchainGetAddress({
-    address_n: bip32ToAddressNList(derivationPathString),
-  })) as { address: string };
-
-  const signTransaction = async ({ assetValue, recipient, sender, memo }: SignTransactionParams) => {
-    const account = await toolbox.getAccount(sender);
-    if (!account) throw new SwapKitError("wallet_keepkey_account_not_found");
-    const { accountNumber, sequence = 0 } = account;
-
-    const isTransfer = recipient && recipient !== "";
-    const msg = buildAminoMsg({ assetValue, memo, recipient, sender });
-
-    const signDoc = makeSignDoc(
-      [msg],
-      getDefaultChainFee(Chain.THORChain),
-      THORConfig.chainId,
-      memo,
-      accountNumber?.toString(),
-      sequence,
-    );
-
-    const signedTx = isTransfer
-      ? await sdk.thorchain.thorchainSignAminoTransfer({
-          signDoc: signDoc as TypesThorchainSignDocTransfer,
-          signerAddress: sender,
-        })
-      : await sdk.thorchain.thorchainSignAminoDeposit({
-          signDoc: signDoc as TypesThorchainSignDocDeposit,
-          signerAddress: sender,
-        });
-    const decodedBytes = atob(signedTx.serialized);
-    return new Uint8Array(decodedBytes.length).map((_, i) => decodedBytes.charCodeAt(i));
-  };
-
-  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-    const rpcUrl = await getRPCUrl(Chain.THORChain);
-    const stargateClient = await createStargateClient(rpcUrl);
-    const signedTransaction = await signTransaction({ assetValue, memo, recipient, sender: fromAddress });
-    const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
-
-    return transactionHash;
-  };
-
-  const deposit = async ({ assetValue, memo }: ThorchainDepositParams) => {
-    const rpcUrl = await getRPCUrl(Chain.THORChain);
-    const stargateClient = await createStargateClient(rpcUrl);
-    const signedTransaction = await signTransaction({ assetValue, memo, sender: fromAddress });
-    const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
-
-    return transactionHash;
-  };
-
-  // const signMessage = async (message: string) => {
-  //   const stargateClient = await createStargateClient(RPCUrl.THORChain);
-  //   // return signedTx;
-  // };
-
-  return { ...toolbox, address: fromAddress, deposit, transfer };
-}

package/src/keepkey/chains/utxo.ts

@@ -1,137 +0,0 @@
-import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
-import {
-  Chain,
-  DerivationPath,
-  type DerivationPathArray,
-  derivationPathToString,
-  FeeOption,
-  type GenericTransferParams,
-  SwapKitError,
-  type UTXOChain,
-} from "@swapkit/helpers";
-import type { UTXOToolboxes } from "@swapkit/toolboxes/utxo";
-import type { Psbt } from "bitcoinjs-lib";
-import { bip32ToAddressNList, ChainToKeepKeyName } from "../coins";
-
-interface KeepKeyInputObject {
-  addressNList: number[];
-  scriptType: string;
-  amount: string;
-  vout: number;
-  txid: string;
-  hex: string;
-}
-
-export async function utxoWalletMethods({
-  sdk,
-  chain,
-  derivationPath,
-}: {
-  sdk: KeepKeySdk;
-  chain: Exclude<UTXOChain, typeof Chain.Zcash>;
-  derivationPath?: DerivationPathArray;
-}): Promise<
-  UTXOToolboxes[UTXOChain] & {
-    address: string;
-    signTransaction: (psbt: Psbt, inputs: KeepKeyInputObject[], memo?: string) => Promise<string>;
-  }
-> {
-  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 signTransaction = async (psbt: Psbt, inputs: KeepKeyInputObject[], memo = "") => {
-    const outputs = psbt.txOutputs
-      .map((output) => {
-        const { value, address, change } = output as {
-          address: string;
-          script: Buffer;
-          value: number;
-          change?: boolean;
-        };
-
-        const outputAddress =
-          // @ts-expect-error - stripToCashAddress is not defined in the UTXO toolbox just only on BCH
-          chain === Chain.BitcoinCash ? toolbox.stripToCashAddress(address) : address;
-
-        if (change || address === walletAddress) {
-          return {
-            addressNList: addressInfo.address_n,
-            addressType: "change",
-            amount: value,
-            isChange: true,
-            scriptType,
-          };
-        }
-
-        if (outputAddress) {
-          return { address: outputAddress, addressType: "spend", amount: value };
-        }
-
-        return null;
-      })
-      .filter(Boolean);
-
-    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 { psbt, 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(psbt, inputs, memo);
-    return toolbox.broadcastTx(txHex);
-  };
-
-  return { ...toolbox, address: walletAddress, signTransaction, transfer };
-}

package/src/keepkey/coins.ts

@@ -1,67 +0,0 @@
-/*
-    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

@@ -1,155 +0,0 @@
-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;
-    },
-  name: "connectKeepkey",
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Cosmos,
-    Chain.Dogecoin,
-    Chain.Dash,
-    Chain.Ethereum,
-    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, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-
-  switch (chain) {
-    case Chain.BinanceSmartChain:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.Ethereum:
-    case Chain.Monad:
-    case Chain.XLayer: {
-      const provider = await getProvider(chain);
-      const signer = new KeepKeySigner({ chain, derivationPath, provider, sdk });
-      const toolbox = await getEvmToolbox(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

@@ -1,84 +0,0 @@
-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[];
-  };
-}