@swapkit/wallet-hardware 4.8.1 → 4.8.3

package/package.json

@@ -22,7 +22,7 @@
     "@near-js/transactions": "~2.5.0",
     "@scure/base": "2.0.0",
     "@swapkit/helpers": "^4.13.0",
-    "@swapkit/toolboxes": "^4.15.0",
+    "@swapkit/toolboxes": "^4.15.5",
     "@swapkit/utxo-signer": "^2.1.1",
     "@swapkit/wallet-core": "^4.2.0",
     "@trezor/connect-web": "~9.6.4",
@@ -89,7 +89,7 @@
       "types": "./dist/types/trezor/index.d.ts"
     }
   },
-  "files": ["dist/"],
+  "files": ["dist/", "src/"],
   "homepage": "https://github.com/swapkit/wallets",
   "license": "SEE LICENSE IN LICENSE",
   "name": "@swapkit/wallet-hardware",
@@ -107,5 +107,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "4.8.1"
+  "version": "4.8.3"
 }

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 "@swapkit/helpers";
+import {
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  GAIAConfig,
+  getRPCUrl,
+} from "@swapkit/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(
+    "@swapkit/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,141 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  type Chain,
+  ChainToChainId,
+  type DerivationPathArray,
+  derivationPathToString,
+  NetworkDerivationPath,
+  SwapKitError,
+} from "@swapkit/helpers";
+import type { JsonRpcProvider, Provider, TransactionRequest, TypedDataDomain, TypedDataField } 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 = async (
+    domain: TypedDataDomain,
+    types: Record<string, TypedDataField[]>,
+    value: Record<string, unknown>,
+    explicitPrimaryType?: string,
+  ) => {
+    const { buildEIP712DomainType } = await import("@swapkit/toolboxes/evm");
+    const { TypedDataEncoder } = await import("ethers");
+
+    const { EIP712Domain: _, ...filteredTypes } = types;
+    const primaryType = explicitPrimaryType ?? TypedDataEncoder.from(filteredTypes).primaryType;
+    const domainTypes = buildEIP712DomainType(domain);
+
+    const address = await this.getAddress();
+    const result = await this.sdk.eth.ethSignTypedData({
+      address,
+      typedData: {
+        domain: domain as Record<string, unknown>,
+        message: value,
+        primaryType,
+        types: { EIP712Domain: domainTypes, ...filteredTypes },
+      },
+    });
+
+    if (typeof result !== "string") {
+      throw new SwapKitError("wallet_keepkey_method_not_supported", { method: "signTypedData" });
+    }
+
+    return result.startsWith("0x") ? result : `0x${result}`;
+  };
+
+  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 SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing to address" });
+    if (!gasLimit) throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasLimit" });
+    if (!data) throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing data" });
+
+    const isEIP1559 = !!((maxFeePerGas || maxPriorityFeePerGas) && !gasPrice);
+    if (isEIP1559 && !maxFeePerGas)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing maxFeePerGas" });
+    if (isEIP1559 && !maxPriorityFeePerGas)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing maxPriorityFeePerGas" });
+    if (!(isEIP1559 || gasPrice))
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasPrice" });
+
+    const { toHexString } = await import("@swapkit/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 SwapKitError("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,98 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  type AssetValue,
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  type GenericTransferParams,
+  getRPCUrl,
+  MAYAConfig,
+  SwapKitError,
+} 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 mayachainWalletMethods({
+  sdk,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  derivationPath?: DerivationPathArray;
+}): Promise<any> {
+  const { createStargateClient, getCosmosToolbox } = await import("@swapkit/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("@swapkit/toolboxes/cosmos");
+
+    const account = await toolbox.getAccount(sender);
+    if (!account) throw new SwapKitError("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 "@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

@@ -0,0 +1,93 @@
+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 };
+}