@swapkit/wallet-hardware 4.8.0 → 4.8.2

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 };
+}

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,
+  };
+}