@tcswap/wallet-hardware 4.2.16

package/package.json

@@ -0,0 +1,101 @@
+{
+  "author": "swapkit-oss",
+  "dependencies": {
+    "@cosmjs/crypto": "0.37.0",
+    "@keepkey/keepkey-sdk": "~0.2.62",
+    "@ledgerhq/devices": "~8.7.0",
+    "@ledgerhq/errors": "~6.27.0",
+    "@ledgerhq/hw-app-btc": "~10.12.0",
+    "@ledgerhq/hw-app-cosmos": "~6.32.9",
+    "@ledgerhq/hw-app-eth": "~6.47.0",
+    "@ledgerhq/hw-app-near": "~6.31.9",
+    "@ledgerhq/hw-app-trx": "~6.31.9",
+    "@ledgerhq/hw-app-xrp": "~6.32.7",
+    "@ledgerhq/hw-transport": "~6.31.0",
+    "@ledgerhq/hw-transport-webhid": "~6.30.9",
+    "@ledgerhq/hw-transport-webusb": "~6.29.13",
+    "@ledgerhq/wallet-api-client": "~1.12.4",
+    "@near-js/crypto": "~2.5.0",
+    "@near-js/transactions": "~2.5.0",
+    "@scure/base": "~2.0.0",
+    "@tcswap/helpers": "4.5.15",
+    "@tcswap/toolboxes": "4.3.15",
+    "@tcswap/wallet-core": "4.0.59",
+    "@trezor/connect-web": "~9.6.4",
+    "cosmjs-types": "~0.10.1",
+    "ethers": "^6.14.0",
+    "ripple-binary-codec": "2.5.1",
+    "ts-pattern": "^5.9.0"
+  },
+  "description": "USwap - Wallet Hardware",
+  "devDependencies": {
+    "@cosmjs/crypto": "0.37.0",
+    "@keepkey/keepkey-sdk": "0.2.62",
+    "@ledgerhq/devices": "8.7.0",
+    "@ledgerhq/errors": "6.27.0",
+    "@ledgerhq/hw-app-btc": "10.12.0",
+    "@ledgerhq/hw-app-cosmos": "6.32.9",
+    "@ledgerhq/hw-app-eth": "6.47.0",
+    "@ledgerhq/hw-app-near": "6.31.9",
+    "@ledgerhq/hw-app-trx": "6.31.9",
+    "@ledgerhq/hw-app-xrp": "6.32.7",
+    "@ledgerhq/hw-transport": "6.31.10",
+    "@ledgerhq/hw-transport-webhid": "6.30.9",
+    "@ledgerhq/hw-transport-webusb": "6.29.13",
+    "@ledgerhq/wallet-api-client": "1.12.4",
+    "@near-js/crypto": "2.5.0",
+    "@near-js/transactions": "2.5.0",
+    "@scure/base": "2.0.0",
+    "@trezor/connect-web": "9.6.4",
+    "cosmjs-types": "0.10.1",
+    "ethers": "6.15.0",
+    "ripple-binary-codec": "2.5.1",
+    "ts-pattern": "5.9.0"
+  },
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./keepkey": {
+      "bun": "./src/keepkey/index.ts",
+      "import": "./dist/keepkey/index.js",
+      "require": "./dist/keepkey/index.cjs",
+      "types": "./dist/types/keepkey/index.d.ts"
+    },
+    "./ledger": {
+      "bun": "./src/ledger/index.ts",
+      "import": "./dist/ledger/index.js",
+      "require": "./dist/ledger/index.cjs",
+      "types": "./dist/types/ledger/index.d.ts"
+    },
+    "./trezor": {
+      "bun": "./src/trezor/index.ts",
+      "import": "./dist/trezor/index.js",
+      "require": "./dist/trezor/index.cjs",
+      "types": "./dist/types/trezor/index.d.ts"
+    }
+  },
+  "files": ["dist/", "src/"],
+  "homepage": "https://github.com/thorchain/TCSwap",
+  "license": "Apache-2.0",
+  "name": "@tcswap/wallet-hardware",
+  "repository": {
+    "directory": "packages/wallet-hardware",
+    "type": "git",
+    "url": "git+https://github.com/thorchain/TCSwap.git"
+  },
+  "scripts": {
+    "build": "bun run ./build.ts",
+    "build:clean": "rm -rf dist && bun run ./build.ts",
+    "clean": "rm -rf dist node_modules *.tsbuildinfo",
+    "test": "echo 'bun test'",
+    "test:ci": "echo 'bun test --coverage'",
+    "type-check": "bun tsc --noEmit",
+    "type-check:go": "tsgo"
+  },
+  "type": "module",
+  "version": "4.2.16"
+}

package/src/index.ts

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

package/src/keepkey/chains/cosmos.ts

@@ -0,0 +1,69 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import type { GenericTransferParams } from "@tcswap/helpers";
+import {
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  GAIAConfig,
+  getRPCUrl,
+} from "@tcswap/helpers";
+
+import { bip32ToAddressNList } from "../coins";
+
+export async function cosmosWalletMethods({
+  sdk,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  derivationPath?: DerivationPathArray;
+}): Promise<any> {
+  const { DEFAULT_COSMOS_FEE_MAINNET, getCosmosToolbox, getFeeRateFromSwapKit, createStargateClient } = await import(
+    "@tcswap/toolboxes/cosmos"
+  );
+  const derivationPathString = derivationPath ? derivationPathToString(derivationPath) : `${DerivationPath.GAIA}/0`;
+
+  const { address: fromAddress } = (await sdk.address.cosmosGetAddress({
+    address_n: bip32ToAddressNList(derivationPathString),
+  })) as { address: string };
+
+  const toolbox = await getCosmosToolbox(Chain.Cosmos);
+
+  if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
+    DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(await getFeeRateFromSwapKit(GAIAConfig.chainId, 500));
+  }
+
+  // TODO support other cosmos assets
+  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
+    const amount = assetValue.getBaseValue("string");
+    const accountInfo = await toolbox.getAccount(fromAddress);
+
+    const keepKeySignedTx = await sdk.cosmos.cosmosSignAmino({
+      signDoc: {
+        account_number: accountInfo?.accountNumber.toString() ?? "",
+        chain_id: GAIAConfig.chainId,
+        fee: DEFAULT_COSMOS_FEE_MAINNET,
+        memo: memo || "",
+        msgs: [
+          {
+            type: "cosmos-sdk/MsgSend",
+            value: { amount: [{ amount, denom: "uatom" }], from_address: fromAddress, to_address: recipient },
+          },
+        ],
+        sequence: accountInfo?.sequence.toString() ?? "",
+      },
+      signerAddress: fromAddress,
+    });
+
+    const decodedBytes = atob(keepKeySignedTx.serialized);
+    const uint8Array = new Uint8Array(decodedBytes.length).map((_, i) => decodedBytes.charCodeAt(i));
+
+    const rpcUrl = await getRPCUrl(Chain.Cosmos);
+    const client = await createStargateClient(rpcUrl);
+    const response = await client.broadcastTx(uint8Array);
+
+    return response.transactionHash;
+  };
+
+  return { ...toolbox, address: fromAddress, transfer };
+}

package/src/keepkey/chains/evm.ts

@@ -0,0 +1,117 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  type Chain,
+  ChainToChainId,
+  type DerivationPathArray,
+  derivationPathToString,
+  NetworkDerivationPath,
+  USwapError,
+} from "@tcswap/helpers";
+import type { JsonRpcProvider, Provider, TransactionRequest } from "ethers";
+import { AbstractSigner } from "ethers";
+
+import { bip32ToAddressNList } from "../coins";
+
+interface KeepKeyEVMSignerParams {
+  sdk: KeepKeySdk;
+  chain: Chain;
+  derivationPath?: DerivationPathArray;
+  provider: Provider | JsonRpcProvider;
+}
+
+export class KeepKeySigner extends AbstractSigner {
+  private sdk: KeepKeySdk;
+  private chain: Chain;
+  private derivationPath: DerivationPathArray;
+  private address: string;
+  readonly provider: Provider | JsonRpcProvider;
+
+  constructor({ sdk, chain, derivationPath, provider }: KeepKeyEVMSignerParams) {
+    super();
+    this.sdk = sdk;
+    this.chain = chain;
+    this.derivationPath = derivationPath || NetworkDerivationPath.ETH;
+    this.address = "";
+    this.provider = provider;
+  }
+
+  signTypedData(): Promise<string> {
+    throw new USwapError("wallet_keepkey_method_not_supported", { method: "signTypedData" });
+  }
+
+  getAddress = async () => {
+    if (this.address) return this.address;
+    const { address } = await this.sdk.address.ethereumGetAddress({
+      address_n: bip32ToAddressNList(derivationPathToString(this.derivationPath)),
+    });
+
+    this.address = address;
+    return address;
+  };
+
+  signMessage = (message: string) => this.sdk.eth.ethSign({ address: this.address, message }) as Promise<string>;
+
+  signTransaction = async ({
+    to,
+    value,
+    gasLimit,
+    nonce,
+    data,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    gasPrice,
+  }: TransactionRequest) => {
+    if (!to) throw new USwapError("wallet_keepkey_invalid_params", { reason: "Missing to address" });
+    if (!gasLimit) throw new USwapError("wallet_keepkey_invalid_params", { reason: "Missing gasLimit" });
+    if (!data) throw new USwapError("wallet_keepkey_invalid_params", { reason: "Missing data" });
+
+    const isEIP1559 = !!((maxFeePerGas || maxPriorityFeePerGas) && !gasPrice);
+    if (isEIP1559 && !maxFeePerGas)
+      throw new USwapError("wallet_keepkey_invalid_params", { reason: "Missing maxFeePerGas" });
+    if (isEIP1559 && !maxPriorityFeePerGas)
+      throw new USwapError("wallet_keepkey_invalid_params", { reason: "Missing maxPriorityFeePerGas" });
+    if (!(isEIP1559 || gasPrice)) throw new USwapError("wallet_keepkey_invalid_params", { reason: "Missing gasPrice" });
+
+    const { toHexString } = await import("@tcswap/toolboxes/evm");
+
+    const nonceValue = nonce
+      ? BigInt(nonce)
+      : BigInt(await this.provider.getTransactionCount(await this.getAddress(), "pending"));
+
+    const input = {
+      addressNList: [2147483692, 2147483708, 2147483648, 0, 0],
+      chainId: toHexString(BigInt(ChainToChainId[this.chain])),
+      data,
+      from: this.address,
+      gas: toHexString(BigInt(gasLimit)),
+      nonce: toHexString(nonceValue),
+      to: to.toString(),
+      value: toHexString(BigInt(value || 0)),
+      ...(isEIP1559 && {
+        maxFeePerGas: toHexString(BigInt(maxFeePerGas?.toString() || "0")),
+        maxPriorityFeePerGas: toHexString(BigInt(maxPriorityFeePerGas?.toString() || "0")),
+      }),
+      ...(!isEIP1559 && {
+        // Fixed syntax error and structure here
+        gasPrice: toHexString(BigInt(gasPrice?.toString() || "0")),
+      }),
+    };
+    const responseSign = await this.sdk.eth.ethSignTransaction(input);
+    return responseSign.serialized;
+  };
+
+  sendTransaction = async (tx: TransactionRequest): Promise<any> => {
+    if (!this.provider) throw new USwapError("wallet_keepkey_no_provider");
+
+    const signedTxHex = await this.signTransaction(tx);
+
+    return await this.provider.broadcastTransaction(signedTxHex);
+  };
+
+  connect = (provider: Provider) =>
+    new KeepKeySigner({ chain: this.chain, derivationPath: this.derivationPath, provider, sdk: this.sdk });
+}

package/src/keepkey/chains/mayachain.ts

@@ -0,0 +1,102 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  type AssetValue,
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  type GenericTransferParams,
+  getRPCUrl,
+  MAYAConfig,
+  USwapError,
+} from "@tcswap/helpers";
+import type { ThorchainDepositParams } from "@tcswap/toolboxes/cosmos";
+
+import { bip32ToAddressNList } from "../coins";
+
+type SignTransactionParams = { assetValue: AssetValue; recipient?: string; sender: string; memo: string | undefined };
+
+export async function mayachainWalletMethods({
+  sdk,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  derivationPath?: DerivationPathArray;
+}): Promise<any> {
+  const { createStargateClient, getCosmosToolbox } = await import("@tcswap/toolboxes/cosmos");
+
+  const toolbox = await getCosmosToolbox(Chain.Maya);
+  const derivationPathString = derivationPath ? derivationPathToString(derivationPath) : `${DerivationPath.MAYA}/0`;
+
+  const { address: fromAddress } = (await sdk.address.mayachainGetAddress({
+    address_n: bip32ToAddressNList(derivationPathString),
+  })) as { address: string };
+
+  const signTransaction = async ({ assetValue, recipient, sender, memo }: SignTransactionParams) => {
+    const importedAmino = await import("@cosmjs/amino");
+    const makeSignDoc = importedAmino.makeSignDoc ?? importedAmino.default?.makeSignDoc;
+    const { getDenomWithChain } = await import("@tcswap/toolboxes/cosmos");
+
+    const account = await toolbox.getAccount(sender);
+    if (!account) throw new USwapError("wallet_keepkey_account_not_found");
+    const { accountNumber, sequence = 0 } = account;
+    const amount = assetValue.getBaseValue("string");
+
+    const isTransfer = recipient && recipient !== "";
+
+    // TODO check if we can move to toolbox created msg
+    const msg = isTransfer
+      ? {
+          type: "mayachain/MsgSend",
+          value: {
+            amount: [{ amount, denom: assetValue.symbol.toLowerCase() }],
+            from_address: sender,
+            to_address: recipient,
+          },
+        }
+      : {
+          type: "mayachain/MsgDeposit",
+          value: { coins: [{ amount, asset: getDenomWithChain(assetValue) }], memo, signer: sender },
+        };
+
+    const signDoc = makeSignDoc(
+      [msg],
+      { amount: [], gas: "500000000" },
+      MAYAConfig.chainId,
+      memo,
+      accountNumber?.toString(),
+      sequence,
+    );
+
+    const sdkMethod = isTransfer ? sdk.mayachain.mayachainSignAminoTransfer : sdk.mayachain.mayachainSignAminoDeposit;
+
+    // @ts-expect-error TC
+    const signedTx = await sdkMethod({ signDoc, 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.Maya);
+    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.Maya);
+    const stargateClient = await createStargateClient(rpcUrl);
+    const signedTransaction = await signTransaction({ assetValue, memo, sender: fromAddress });
+    const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
+
+    return transactionHash;
+  };
+
+  return { ...toolbox, address: fromAddress, deposit, transfer };
+}

package/src/keepkey/chains/ripple.ts

@@ -0,0 +1,88 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  type GenericTransferParams,
+} from "@tcswap/helpers";
+import { getRippleToolbox } from "@tcswap/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

@@ -0,0 +1,97 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { KeepKeySdk, TypesThorchainSignDocDeposit, TypesThorchainSignDocTransfer } from "@keepkey/keepkey-sdk";
+import {
+  type AssetValue,
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  type GenericTransferParams,
+  getRPCUrl,
+  THORConfig,
+  USwapError,
+} from "@tcswap/helpers";
+import type { ThorchainDepositParams } from "@tcswap/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(
+    "@tcswap/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 USwapError("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 };
+}