@swapkit/wallet-hardware 4.8.0 → 4.8.2

package/src/ledger/clients/utxo.ts

@@ -0,0 +1,359 @@
+import type BitcoinApp from "@ledgerhq/hw-app-btc";
+import type { CreateTransactionArg } from "@ledgerhq/hw-app-btc/lib-es/createTransaction";
+import { hex } from "@scure/base";
+import { type DerivationPathArray, derivationPathToString, getWalletFormatFor, SwapKitError } from "@swapkit/helpers";
+import type { UTXOType } from "@swapkit/toolboxes/utxo";
+import type { PCZT, Transaction } from "@swapkit/utxo-signer";
+
+import { getLedgerTransport } from "../helpers/getLedgerTransport";
+
+const nonSegwitLedgerChains = ["bitcoin-cash", "dash", "dogecoin", "zcash"];
+
+type Params = {
+  tx: Transaction;
+  inputUtxos: UTXOType[];
+  btcApp: BitcoinApp;
+  derivationPath: string;
+  chain: "bitcoin-cash" | "bitcoin" | "litecoin" | "dogecoin" | "dash" | "zcash";
+};
+
+type MultiPathParams = Omit<Params, "derivationPath"> & {
+  /** Derivation paths for each input - one per input */
+  derivationPaths: string[];
+};
+
+const signUTXOTransaction = (
+  { tx, inputUtxos, btcApp, derivationPath, chain }: Params,
+  options?: Partial<CreateTransactionArg>,
+) => {
+  const inputs = inputUtxos.map((item) => {
+    const splitTx = btcApp.splitTransaction(
+      item.txHex || "",
+      !nonSegwitLedgerChains.includes(chain),
+      chain === "zcash",
+    );
+
+    return [splitTx, item.index, undefined as string | null | undefined, undefined as number | null | undefined] as any;
+  });
+
+  const newTxHex = hex.encode(tx.unsignedTx);
+
+  const splitNewTx = btcApp.splitTransaction(newTxHex, true);
+  const outputScriptHex = btcApp.serializeTransactionOutputs(splitNewTx).toString("hex");
+
+  const params: CreateTransactionArg = {
+    additionals: ["bech32"],
+    associatedKeysets: inputs.map(() => derivationPath),
+    inputs,
+    outputScriptHex,
+    segwit: true,
+    useTrustedInputForSegwit: true,
+  };
+
+  return btcApp.createPaymentTransaction({ ...params, ...options });
+};
+
+/**
+ * Sign a UTXO transaction with multiple derivation paths.
+ * Each input can have its own derivation path for HD wallet multi-address support.
+ */
+const signUTXOTransactionWithMultiplePaths = (
+  { tx, inputUtxos, btcApp, derivationPaths, chain }: MultiPathParams,
+  options?: Partial<CreateTransactionArg>,
+) => {
+  if (derivationPaths.length !== inputUtxos.length) {
+    throw new SwapKitError("wallet_ledger_invalid_params", {
+      message: `Derivation paths count (${derivationPaths.length}) must match inputs count (${inputUtxos.length})`,
+    });
+  }
+
+  const inputs = inputUtxos.map((item) => {
+    const splitTx = btcApp.splitTransaction(
+      item.txHex || "",
+      !nonSegwitLedgerChains.includes(chain),
+      chain === "zcash",
+    );
+
+    return [splitTx, item.index, undefined as string | null | undefined, undefined as number | null | undefined] as any;
+  });
+
+  const newTxHex = hex.encode(tx.unsignedTx);
+
+  const splitNewTx = btcApp.splitTransaction(newTxHex, true);
+  const outputScriptHex = btcApp.serializeTransactionOutputs(splitNewTx).toString("hex");
+
+  const params: CreateTransactionArg = {
+    additionals: ["bech32"],
+    associatedKeysets: derivationPaths,
+    inputs,
+    outputScriptHex,
+    segwit: true,
+    useTrustedInputForSegwit: true,
+  };
+
+  return btcApp.createPaymentTransaction({ ...params, ...options });
+};
+
+const BaseLedgerUTXO = ({
+  chain,
+  additionalSignParams,
+}: {
+  chain: "bitcoin-cash" | "bitcoin" | "litecoin" | "dogecoin" | "dash" | "zcash";
+  additionalSignParams?: Partial<CreateTransactionArg>;
+}) => {
+  let btcApp: InstanceType<typeof BitcoinApp>;
+  let transport: any = null;
+
+  async function checkBtcAppAndCreateTransportWebUSB(checkBtcApp = true) {
+    if (checkBtcApp && !btcApp) {
+      new SwapKitError("wallet_ledger_connection_error", {
+        message: `Ledger connection failed:\n${JSON.stringify({ btcApp, checkBtcApp })}`,
+      });
+    }
+
+    transport ||= await getLedgerTransport();
+  }
+
+  async function createTransportWebUSB() {
+    transport = await getLedgerTransport();
+    const BitcoinApp = (await import("@ledgerhq/hw-app-btc")).default;
+
+    btcApp = new BitcoinApp({ currency: chain, transport });
+  }
+
+  return (derivationPathArray?: DerivationPathArray | string) => {
+    const derivationPath =
+      typeof derivationPathArray === "string"
+        ? derivationPathArray
+        : derivationPathToString(derivationPathArray as DerivationPathArray);
+
+    const format = getWalletFormatFor(derivationPath);
+
+    return {
+      connect: async () => {
+        await checkBtcAppAndCreateTransportWebUSB(false);
+        const BitcoinApp = (await import("@ledgerhq/hw-app-btc")).default;
+
+        btcApp = new BitcoinApp({ currency: chain, transport });
+      },
+      getAddress: async () => {
+        const { toCashAddress } = await import("@swapkit/toolboxes/utxo");
+
+        await checkBtcAppAndCreateTransportWebUSB(false);
+
+        const { bitcoinAddress: address } = await btcApp.getWalletPublicKey(derivationPath, { format });
+
+        if (!address) {
+          throw new SwapKitError("wallet_ledger_get_address_error", {
+            message: `Cannot get ${chain} address from ledger derivation path: ${derivationPath}`,
+          });
+        }
+
+        return chain === "bitcoin-cash" && format === "legacy"
+          ? toCashAddress(address).replace(/(bchtest:|bitcoincash:)/, "")
+          : address;
+      },
+      getExtendedPublicKey: async (path = "84'/0'/0'", xpubVersion = 76067358) => {
+        await checkBtcAppAndCreateTransportWebUSB(false);
+
+        return btcApp.getWalletXpub({ path, xpubVersion });
+      },
+
+      signPCZT: async (pczt: PCZT): Promise<PCZT> => {
+        if (chain !== "zcash") {
+          throw new SwapKitError("wallet_ledger_chain_not_supported", {
+            message: "PCZT signing is only supported for Zcash",
+          });
+        }
+
+        await createTransportWebUSB();
+
+        const { ZcashTransaction, Script } = await import("@swapkit/utxo-signer");
+
+        const global = pczt.getGlobal();
+
+        const unsignedTx = new ZcashTransaction({
+          consensusBranchId: global.consensusBranchId,
+          expiryHeight: global.expiryHeight,
+          lockTime: global.lockTime,
+          version: global.txVersion,
+          versionGroupId: global.versionGroupId,
+        });
+
+        const inputUtxos: UTXOType[] = [];
+
+        for (let i = 0; i < pczt.inputsLength; i++) {
+          const input = pczt.getInput(i);
+
+          unsignedTx.addInput({
+            index: input.index,
+            script: new Uint8Array(),
+            sequence: input.sequence ?? 0xffffffff,
+            txid: input.txid,
+            value: input.value,
+          });
+
+          inputUtxos.push({
+            hash: hex.encode(new Uint8Array([...input.txid].reverse())),
+            index: input.index,
+            txHex: buildMinimalPrevTxHex(input, global),
+            value: Number(input.value),
+            witnessUtxo: { script: input.scriptPubkey, value: Number(input.value) },
+          } as UTXOType);
+        }
+
+        for (let i = 0; i < pczt.outputsLength; i++) {
+          const output = pczt.getOutput(i);
+          unsignedTx.addOutput({ amount: output.value, script: output.scriptPubkey });
+        }
+
+        const signedTxHex = await signUTXOTransaction(
+          { btcApp, chain, derivationPath, inputUtxos, tx: unsignedTx as unknown as Transaction },
+          {
+            ...additionalSignParams,
+            expiryHeight: (() => {
+              const buf = Buffer.alloc(4);
+              buf.writeUInt32LE(global.expiryHeight);
+              return buf;
+            })(),
+            lockTime: global.lockTime,
+          },
+        );
+
+        const signedTx = ZcashTransaction.fromHex(signedTxHex, { allowUnknownOutputs: true });
+        const signedPczt = pczt.clone();
+
+        for (let i = 0; i < signedTx.inputsLength; i++) {
+          const signedInput = signedTx.getInput(i);
+          if (signedInput.script && signedInput.script.length > 0) {
+            const scriptParts = Script.decode(signedInput.script);
+            if (scriptParts.length >= 2) {
+              signedPczt.addSignature(i, scriptParts[1] as Uint8Array, scriptParts[0] as Uint8Array);
+            }
+          }
+        }
+
+        return signedPczt;
+      },
+      signTransaction: async (tx: Transaction, inputUtxos: UTXOType[]) => {
+        await createTransportWebUSB();
+
+        return signUTXOTransaction({ btcApp, chain, derivationPath, inputUtxos, tx }, additionalSignParams);
+      },
+
+      /**
+       * Sign a transaction with multiple derivation paths for HD wallet multi-address support.
+       * Each input can be signed with its own derivation path.
+       */
+      signTransactionWithMultiplePaths: async (tx: Transaction, inputUtxos: UTXOType[], derivationPaths: string[]) => {
+        await createTransportWebUSB();
+
+        return signUTXOTransactionWithMultiplePaths(
+          { btcApp, chain, derivationPaths, inputUtxos, tx },
+          additionalSignParams,
+        );
+      },
+    };
+  };
+};
+
+function buildMinimalPrevTxHex(
+  input: { txid: Uint8Array; index: number; scriptPubkey: Uint8Array; value: bigint },
+  global: { txVersion: number; versionGroupId: number; expiryHeight: number; lockTime: number },
+): string {
+  const parts: number[] = [];
+
+  const version = (global.txVersion | 0x80000000) >>> 0;
+  parts.push(version & 0xff, (version >> 8) & 0xff, (version >> 16) & 0xff, (version >> 24) & 0xff);
+
+  const vgid = global.versionGroupId;
+  parts.push(vgid & 0xff, (vgid >> 8) & 0xff, (vgid >> 16) & 0xff, (vgid >> 24) & 0xff);
+
+  parts.push(0);
+
+  const outputCount = input.index + 1;
+  if (outputCount < 0xfd) {
+    parts.push(outputCount);
+  } else {
+    parts.push(0xfd, outputCount & 0xff, (outputCount >> 8) & 0xff);
+  }
+
+  for (let i = 0; i < input.index; i++) {
+    parts.push(0, 0, 0, 0, 0, 0, 0, 0);
+    parts.push(0);
+  }
+
+  const value = input.value;
+  parts.push(
+    Number(value & 0xffn),
+    Number((value >> 8n) & 0xffn),
+    Number((value >> 16n) & 0xffn),
+    Number((value >> 24n) & 0xffn),
+    Number((value >> 32n) & 0xffn),
+    Number((value >> 40n) & 0xffn),
+    Number((value >> 48n) & 0xffn),
+    Number((value >> 56n) & 0xffn),
+  );
+
+  const script = input.scriptPubkey;
+  if (script.length < 0xfd) {
+    parts.push(script.length);
+  } else {
+    parts.push(0xfd, script.length & 0xff, (script.length >> 8) & 0xff);
+  }
+  for (const byte of script) {
+    parts.push(byte);
+  }
+
+  parts.push(
+    global.lockTime & 0xff,
+    (global.lockTime >> 8) & 0xff,
+    (global.lockTime >> 16) & 0xff,
+    (global.lockTime >> 24) & 0xff,
+  );
+  parts.push(
+    global.expiryHeight & 0xff,
+    (global.expiryHeight >> 8) & 0xff,
+    (global.expiryHeight >> 16) & 0xff,
+    (global.expiryHeight >> 24) & 0xff,
+  );
+  parts.push(0, 0, 0, 0, 0, 0, 0, 0); // value balance
+  parts.push(0); // empty sapling spends
+  parts.push(0); // empty sapling outputs
+  parts.push(0); // empty joinsplits
+
+  return hex.encode(new Uint8Array(parts));
+}
+
+export const BitcoinLedger = BaseLedgerUTXO({ chain: "bitcoin" });
+export const LitecoinLedger = BaseLedgerUTXO({ chain: "litecoin" });
+
+export const BitcoinCashLedger = BaseLedgerUTXO({
+  additionalSignParams: { additionals: ["abc"], segwit: false, sigHashType: 0x41 },
+  chain: "bitcoin-cash",
+});
+
+export const DogecoinLedger = BaseLedgerUTXO({
+  additionalSignParams: { additionals: [], segwit: false, useTrustedInputForSegwit: false },
+  chain: "dogecoin",
+});
+
+export const DashLedger = BaseLedgerUTXO({
+  additionalSignParams: { additionals: [], segwit: false, useTrustedInputForSegwit: false },
+  chain: "dash",
+});
+
+export const ZcashLedger = BaseLedgerUTXO({
+  additionalSignParams: {
+    additionals: ["zcash", "sapling"],
+    expiryHeight: (() => {
+      const buf = Buffer.alloc(4);
+      buf.writeUInt32LE(0);
+      return buf;
+    })(),
+    lockTime: 0,
+    segwit: false,
+    useTrustedInputForSegwit: false,
+  },
+  chain: "zcash",
+});

package/src/ledger/clients/xrp.ts

@@ -0,0 +1,50 @@
+import Xrp from "@ledgerhq/hw-app-xrp";
+import type Transport from "@ledgerhq/hw-transport";
+import { Chain, type DerivationPathArray, derivationPathToString, NetworkDerivationPath } from "@swapkit/helpers";
+import type { RippleTransaction } from "@swapkit/toolboxes/ripple";
+import { encode } from "ripple-binary-codec";
+import type { Payment } from "xrpl";
+import { getLedgerTransport } from "../helpers/getLedgerTransport";
+
+const TF_FULLY_CANONICAL_SIG = 2147483648;
+
+function cleanTransactionObject(obj: Record<string, any>) {
+  const cleaned: Record<string, any> = {};
+  for (const key in obj) {
+    if (obj[key] !== null && obj[key] !== undefined) {
+      cleaned[key] = obj[key];
+    }
+  }
+  return cleaned;
+}
+
+function establishConnection(transport: Transport) {
+  return new Xrp(transport);
+}
+
+export const XRPLedger = async (derivationPath?: DerivationPathArray) => {
+  const path = derivationPathToString(derivationPath || NetworkDerivationPath[Chain.Ripple]);
+  const transport = await getLedgerTransport();
+  const xrpInstance = establishConnection(transport);
+
+  const { address, publicKey } = await xrpInstance.getAddress(path);
+
+  async function signTransaction(transaction: Payment | RippleTransaction) {
+    const { hashes } = await import("@swapkit/toolboxes/ripple");
+    const cleanedTxWithPubKey = cleanTransactionObject(transaction);
+    const transactionJSON = {
+      ...cleanedTxWithPubKey,
+      Flags: transaction.Flags || TF_FULLY_CANONICAL_SIG,
+      SigningPubKey: publicKey.toUpperCase(),
+    };
+
+    const transactionToSignOnLedger = encode(transactionJSON);
+    const txnSignature = await xrpInstance.signTransaction(path, transactionToSignOnLedger);
+    const tx_blob = encode({ ...transactionJSON, TxnSignature: txnSignature });
+    const hash = hashes.hashSignedTx(tx_blob);
+
+    return { hash, tx_blob };
+  }
+
+  return { getAddress: () => address, signTransaction };
+};

package/src/ledger/cosmosTypes.ts

@@ -0,0 +1,98 @@
+import { SwapKitError } from "@swapkit/helpers";
+
+export interface Coin {
+  readonly denom: string;
+  readonly amount: string;
+}
+
+export interface EncodeObject {
+  readonly typeUrl: string;
+  readonly value: any;
+}
+
+export interface AminoMsg {
+  readonly type: string;
+  readonly value: any;
+}
+
+export interface AminoMsgSend extends AminoMsg {
+  readonly type: "cosmos-sdk/MsgSend";
+  readonly value: {
+    /** Bech32 account address */
+    readonly from_address: string;
+    /** Bech32 account address */
+    readonly to_address: string;
+    readonly amount: readonly Coin[];
+  };
+}
+
+export interface AminoConverter {
+  readonly aminoType: string;
+  readonly toAmino: (value: any) => any;
+  readonly fromAmino: (value: any) => any;
+}
+
+/** A map from protobuf type URL to the AminoConverter implementation if supported on chain */
+export type AminoConverters = Record<string, AminoConverter | "not_supported_by_chain">;
+
+function isAminoConverter(
+  converter: [string, AminoConverter | "not_supported_by_chain"],
+): converter is [string, AminoConverter] {
+  return typeof converter[1] !== "string";
+}
+
+/**
+ * A map from Stargate message types as used in the messages's `Any` type
+ * to Amino types.
+ */
+export class AminoTypes {
+  // The map type here ensures uniqueness of the protobuf type URL in the key.
+  // There is no uniqueness guarantee of the Amino type identifier in the type
+  // system or constructor. Instead it's the user's responsibility to ensure
+  // there is no overlap when fromAmino is called.
+  private readonly register: Record<string, AminoConverter | "not_supported_by_chain">;
+
+  constructor(types: AminoConverters) {
+    this.register = types;
+  }
+
+  toAmino({ typeUrl, value }: EncodeObject): AminoMsg {
+    const converter = this.register[typeUrl];
+    if (converter === "not_supported_by_chain") {
+      throw new SwapKitError("wallet_ledger_chain_not_supported", {
+        reason: `The message type '${typeUrl}' cannot be signed using the Amino JSON sign mode because this is not supported by chain.`,
+      });
+    }
+    if (!converter) {
+      throw new SwapKitError("wallet_ledger_invalid_params", {
+        reason: `Type URL '${typeUrl}' does not exist in the Amino message type register.`,
+      });
+    }
+    return { type: converter.aminoType, value: converter.toAmino(value) };
+  }
+
+  fromAmino({ type, value }: AminoMsg): EncodeObject {
+    const matches = Object.entries(this.register)
+      .filter(isAminoConverter)
+      .filter(([_typeUrl, { aminoType }]) => aminoType === type);
+
+    if (matches.length === 0) {
+      throw new SwapKitError("wallet_ledger_invalid_params", {
+        reason: `Amino type identifier '${type}' does not exist in the Amino message type register.`,
+      });
+    }
+
+    if (matches.length > 1) {
+      throw new SwapKitError("wallet_ledger_invalid_params", {
+        reason: `Multiple types are registered with Amino type identifier '${type}': '${matches
+          .map(([key, _value]) => key)
+          .sort()
+          .join("', '")}'. Thus fromAmino cannot be performed.`,
+      });
+    }
+
+    const [typeUrl, converter] = matches[0] as [string, AminoConverter];
+
+    return { typeUrl, value: converter.fromAmino(value) };
+  }
+}

package/src/ledger/helpers/getLedgerAddress.ts

@@ -0,0 +1,76 @@
+import { Chain, SwapKitError, WalletOption } from "@swapkit/helpers";
+
+import type { getNearLedgerClient } from "../clients/near";
+import type { SuiLedger } from "../clients/sui";
+import type { TronLedger } from "../clients/tron";
+import type { XRPLedger } from "../clients/xrp";
+import type { LEDGER_SUPPORTED_CHAINS } from "../index";
+import type { CosmosLedgerClients, EVMLedgerClients, UTXOLedgerClients } from "../types";
+import type { getLedgerClient } from "./getLedgerClient";
+
+export const getLedgerAddress = async <
+  T extends (typeof LEDGER_SUPPORTED_CHAINS)[number],
+  L extends Awaited<ReturnType<typeof getLedgerClient<T>>>,
+>({
+  chain,
+  ledgerClient,
+}: {
+  chain: T;
+  ledgerClient: L;
+}) => {
+  if (!ledgerClient) return "";
+
+  switch (chain) {
+    case Chain.Cosmos:
+    case Chain.THORChain: {
+      return (ledgerClient as CosmosLedgerClients).connect();
+    }
+
+    case Chain.Ethereum:
+    case Chain.BinanceSmartChain:
+    case Chain.Avalanche:
+    case Chain.Polygon:
+    case Chain.Arbitrum:
+    case Chain.Berachain:
+    case Chain.Optimism:
+    case Chain.Base:
+    case Chain.Aurora:
+    case Chain.Gnosis:
+    case Chain.Monad:
+    case Chain.XLayer: {
+      return (ledgerClient as EVMLedgerClients).getAddress();
+    }
+
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dash:
+    case Chain.Dogecoin:
+    case Chain.Litecoin:
+    case Chain.Zcash: {
+      const ledger = ledgerClient as UTXOLedgerClients;
+      await ledger.connect();
+      const address = await ledger.getAddress();
+
+      return chain === Chain.BitcoinCash ? address.replace("bitcoincash:", "") : address;
+    }
+
+    case Chain.Near: {
+      return await (ledgerClient as Awaited<ReturnType<typeof getNearLedgerClient>>).getAddress();
+    }
+
+    case Chain.Ripple: {
+      return (ledgerClient as Awaited<ReturnType<typeof XRPLedger>>).getAddress();
+    }
+
+    case Chain.Tron: {
+      return (ledgerClient as Awaited<ReturnType<typeof TronLedger>>).getAddress();
+    }
+
+    case Chain.Sui: {
+      return (ledgerClient as Awaited<ReturnType<typeof SuiLedger>>).connect();
+    }
+
+    default:
+      throw new SwapKitError("wallet_chain_not_supported", { chain, wallet: WalletOption.LEDGER });
+  }
+};