@swapkit/wallet-hardware 4.2.11 → 4.6.0

package/src/ledger/clients/evm.ts

@@ -1,141 +0,0 @@
-import type EthereumApp from "@ledgerhq/hw-app-eth";
-import {
-  ChainId,
-  type DerivationPathArray,
-  derivationPathToString,
-  NetworkDerivationPath,
-  SwapKitError,
-} from "@swapkit/helpers";
-import { AbstractSigner, type Provider, type TransactionRequest } from "ethers";
-
-import { getLedgerTransport } from "../helpers/getLedgerTransport";
-
-class EVMLedgerInterface extends AbstractSigner {
-  chainId: ChainId = ChainId.Ethereum;
-  derivationPath = "";
-  ledgerApp: InstanceType<typeof EthereumApp> | null = null;
-  ledgerTimeout = 50000;
-
-  constructor({
-    provider,
-    derivationPath = NetworkDerivationPath.OP,
-    chainId = ChainId.Optimism,
-  }: { provider: Provider; derivationPath?: DerivationPathArray | string; chainId?: ChainId }) {
-    super(provider);
-
-    this.chainId = chainId || ChainId.Ethereum;
-    this.derivationPath = typeof derivationPath === "string" ? derivationPath : derivationPathToString(derivationPath);
-
-    Object.defineProperty(this, "provider", { enumerable: true, value: provider || null, writable: false });
-  }
-
-  connect = (provider: Provider) =>
-    new EVMLedgerInterface({ chainId: this.chainId, derivationPath: this.derivationPath, provider });
-
-  checkOrCreateTransportAndLedger = async () => {
-    if (this.ledgerApp) return;
-    await this.createTransportAndLedger();
-  };
-
-  createTransportAndLedger = async () => {
-    const transport = await getLedgerTransport();
-    const EthereumApp = (await import("@ledgerhq/hw-app-eth")).default;
-
-    this.ledgerApp = new EthereumApp(transport);
-  };
-
-  getAddress = async () => {
-    const response = await this.getAddressAndPubKey();
-    if (!response) throw new SwapKitError("wallet_ledger_failed_to_get_address");
-    return response.address;
-  };
-
-  getAddressAndPubKey = async () => {
-    await this.createTransportAndLedger();
-    return this.ledgerApp?.getAddress(this.derivationPath);
-  };
-
-  showAddressAndPubKey = async () => {
-    await this.createTransportAndLedger();
-    return this.ledgerApp?.getAddress(this.derivationPath, true);
-  };
-
-  signMessage = async (messageHex: string) => {
-    const { Signature } = await import("ethers");
-    await this.createTransportAndLedger();
-
-    const sig = await this.ledgerApp?.signPersonalMessage(this.derivationPath, messageHex);
-
-    if (!sig) throw new SwapKitError("wallet_ledger_signing_error");
-
-    sig.r = `0x${sig.r}`;
-    sig.s = `0x${sig.s}`;
-    return Signature.from(sig).serialized;
-  };
-
-  sendTransaction = async (tx: TransactionRequest): Promise<any> => {
-    if (!this.provider) throw new SwapKitError("wallet_ledger_no_provider");
-
-    const signedTxHex = await this.signTransaction(tx);
-
-    return await this.provider.broadcastTransaction(signedTxHex);
-  };
-
-  signTypedData(): Promise<string> {
-    throw new SwapKitError("wallet_ledger_method_not_supported", { method: "signTypedData" });
-  }
-
-  signTransaction = async (tx: TransactionRequest) => {
-    const { Transaction } = await import("ethers");
-    await this.createTransportAndLedger();
-
-    const transactionCount = await this.provider?.getTransactionCount(tx.from || (await this.getAddress()));
-
-    const baseTx = {
-      chainId: tx.chainId || this.chainId,
-      data: tx.data,
-      gasLimit: tx.gasLimit,
-      ...(tx.gasPrice && { gasPrice: tx.gasPrice }),
-      ...(!tx.gasPrice &&
-        tx.maxFeePerGas && { maxFeePerGas: tx.maxFeePerGas, maxPriorityFeePerGas: tx.maxPriorityFeePerGas }),
-      nonce: tx.nonce !== undefined ? Number((tx.nonce || transactionCount || 0).toString()) : transactionCount,
-      to: tx.to?.toString(),
-      type: tx.type && !Number.isNaN(tx.type) ? tx.type : tx.maxFeePerGas ? 2 : 0,
-      value: tx.value,
-    };
-
-    // ledger expects the tx to be serialized without the 0x prefix
-    const unsignedTx = Transaction.from(baseTx).unsignedSerialized.slice(2);
-
-    const { ledgerService } = await import("@ledgerhq/hw-app-eth");
-
-    const resolution = await ledgerService.resolveTransaction(unsignedTx, {}, { erc20: true, externalPlugins: true });
-
-    const signature = await this.ledgerApp?.signTransaction(this.derivationPath, unsignedTx, resolution);
-
-    if (!signature) throw new SwapKitError("wallet_ledger_signing_error");
-
-    const { r, s, v } = signature;
-
-    return Transaction.from({ ...baseTx, signature: { r: `0x${r}`, s: `0x${s}`, v: Number(BigInt(v)) } }).serialized;
-  };
-}
-
-type LedgerParams = { provider: Provider; derivationPath?: DerivationPathArray };
-
-export const ArbitrumLedger = (params: LedgerParams) =>
-  new EVMLedgerInterface({ ...params, chainId: ChainId.Arbitrum });
-export const AuroraLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.Aurora });
-export const AvalancheLedger = (params: LedgerParams) =>
-  new EVMLedgerInterface({ ...params, chainId: ChainId.Avalanche });
-export const BaseLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.Base });
-export const EthereumLedger = (params: LedgerParams) =>
-  new EVMLedgerInterface({ ...params, chainId: ChainId.Ethereum });
-export const GnosisLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.Gnosis });
-export const OptimismLedger = (params: LedgerParams) =>
-  new EVMLedgerInterface({ ...params, chainId: ChainId.Optimism });
-export const PolygonLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.Polygon });
-export const BinanceSmartChainLedger = (params: LedgerParams) =>
-  new EVMLedgerInterface({ ...params, chainId: ChainId.BinanceSmartChain });
-export const MonadLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.Monad });
-export const XLayerLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.XLayer });

package/src/ledger/clients/near.ts

@@ -1,63 +0,0 @@
-import type { SignedTransaction, Transaction } from "@near-js/transactions";
-import type { DerivationPathArray } from "@swapkit/helpers";
-import type { NearSigner } from "@swapkit/toolboxes/near";
-import { getLedgerTransport } from "../helpers/getLedgerTransport";
-
-export async function getNearLedgerClient(derivationPath?: DerivationPathArray) {
-  const Near = (await import("@ledgerhq/hw-app-near")).default;
-  const { Chain, NetworkDerivationPath, SwapKitError } = await import("@swapkit/helpers");
-  const transport = await getLedgerTransport();
-  const nearApp = new Near(transport);
-
-  const path = (derivationPath || NetworkDerivationPath[Chain.Near]).join("'/").concat("'");
-
-  const { address, publicKey: pubKeyHex } = await nearApp.getAddress(path);
-
-  const signer = {
-    getAddress() {
-      return Promise.resolve(address);
-    },
-    async getPublicKey() {
-      const { PublicKey } = await import("@near-js/crypto");
-      return PublicKey.fromString(`ed25519:${pubKeyHex}`);
-    },
-
-    signDelegateAction(_delegateAction: any) {
-      return Promise.reject(
-        new SwapKitError("wallet_ledger_method_not_supported", { method: "signDelegateAction", wallet: "Ledger" }),
-      );
-    },
-
-    signNep413Message(
-      _message: string,
-      _accountId: string,
-      _recipient: string,
-      _nonce: Uint8Array,
-      _callbackUrl?: string,
-    ) {
-      return Promise.reject(
-        new SwapKitError("wallet_ledger_method_not_supported", { method: "signNep413Message", wallet: "Ledger" }),
-      );
-    },
-
-    async signTransaction(transaction: Transaction) {
-      const { Signature, SignedTransaction } = await import("@near-js/transactions");
-      try {
-        const signatureArray = await nearApp.signTransaction(transaction.encode(), path);
-        if (!signatureArray) {
-          throw new Error("Signature undefined");
-        }
-
-        const signature = new Signature({ data: signatureArray, keyType: 0 });
-
-        const signedTransaction = new SignedTransaction({ signature, transaction });
-
-        return [signatureArray, signedTransaction] as [Uint8Array<ArrayBufferLike>, SignedTransaction];
-      } catch (error) {
-        throw new SwapKitError("wallet_ledger_signing_error", { error });
-      }
-    },
-  };
-
-  return signer as NearSigner;
-}

package/src/ledger/clients/thorchain/common.ts

@@ -1,93 +0,0 @@
-export const CLA = 0x55;
-export const CHUNK_SIZE = 250;
-export const APP_KEY = "CSM";
-
-export const INS = {
-  GET_ADDR_SECP256K1: 0x04,
-  GET_VERSION: 0x00,
-  INS_PUBLIC_KEY_SECP256K1: 0x01, // Obsolete
-  SIGN_SECP256K1: 0x02,
-};
-
-export const PAYLOAD_TYPE = { ADD: 0x01, INIT: 0x00, LAST: 0x02 };
-
-export const P1_VALUES = { ONLY_RETRIEVE: 0x00, SHOW_ADDRESS_IN_DEVICE: 0x01 };
-
-export const P2_VALUES = { JSON: 0x0 };
-
-export const ERROR_CODE = { NoError: 0x9000 };
-
-const ERROR_DESCRIPTION: any = {
-  1: "U2F: Unknown",
-  2: "U2F: Bad request",
-  3: "U2F: Configuration unsupported",
-  4: "U2F: Device Ineligible",
-  5: "U2F: Timeout",
-  14: "Timeout",
-  25600: "Execution Error",
-  26368: "Wrong Length",
-  26626: "Error deriving keys",
-  27010: "Empty Buffer",
-  27011: "Output buffer too small",
-  27012: "Data is invalid",
-  27013: "Conditions not satisfied",
-  27014: "Transaction rejected",
-  27264: "Bad key handle",
-  27392: "Invalid P1/P2",
-  27904: "Instruction not supported",
-  28160: "App does not seem to be open",
-  28416: "Unknown error",
-  28417: "Sign/verify error",
-  36864: "No errors",
-  36865: "Device is busy",
-};
-
-export function errorCodeToString(statusCode: number) {
-  if (statusCode in ERROR_DESCRIPTION) return ERROR_DESCRIPTION[statusCode];
-  return `Unknown Status Code: ${statusCode}`;
-}
-
-function isDict(v: any) {
-  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date);
-}
-
-export function processErrorResponse(response: any) {
-  if (response) {
-    if (isDict(response)) {
-      if (Object.hasOwn(response, "statusCode")) {
-        return { error_message: errorCodeToString(response.statusCode), return_code: response.statusCode };
-      }
-
-      if (Object.hasOwn(response, "return_code") && Object.hasOwn(response, "error_message")) {
-        return response;
-      }
-    }
-    return { error_message: response.toString(), return_code: 0xffff };
-  }
-
-  return { error_message: response.toString(), return_code: 0xffff };
-}
-
-export function getVersion(transport: any) {
-  return transport.send(CLA, INS.GET_VERSION, 0, 0).then((response: any) => {
-    const errorCodeData = response.slice(-2);
-    const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
-
-    let targetId = 0;
-    if (response.length >= 9) {
-      targetId = (response[5] << 24) + (response[6] << 16) + (response[7] << 8) + (response[8] << 0);
-    }
-
-    return {
-      device_locked: response[4] === 1,
-      error_message: errorCodeToString(returnCode),
-      major: response[1],
-      minor: response[2],
-      patch: response[3],
-      return_code: returnCode,
-      target_id: targetId.toString(16),
-      // ///
-      test_mode: response[0] !== 0,
-    };
-  }, processErrorResponse);
-}

package/src/ledger/clients/thorchain/helpers.ts

@@ -1,120 +0,0 @@
-import { SwapKitError } from "@swapkit/helpers";
-import { CLA, ERROR_CODE, errorCodeToString, INS, P2_VALUES, PAYLOAD_TYPE, processErrorResponse } from "./common";
-
-export function serializePathv1(path: number[]) {
-  if (path == null || path.length < 3) {
-    throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Path too short" });
-  }
-  if (path.length > 10) {
-    throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Path too long" });
-  }
-  const buf = Buffer.alloc(1 + 4 * path.length);
-  buf.writeUInt8(path.length, 0);
-  for (let i = 0; i < path.length; i += 1) {
-    let v = path[i] || 0;
-    if (i < 3) {
-      // eslint-disable-next-line no-bitwise
-      v |= 0x80000000; // Harden
-    }
-    buf.writeInt32LE(v, 1 + i * 4);
-  }
-  return buf;
-}
-
-export function signSendChunkv1(app: any, chunkIdx: number, _chunkNum: number, chunk: Buffer, txType = P2_VALUES.JSON) {
-  return app.transport
-    .send(CLA, INS.SIGN_SECP256K1, chunkIdx, txType, chunk, [ERROR_CODE.NoError, 0x6984, 0x6a80])
-    .then((response: any) => {
-      const errorCodeData = response.slice(-2);
-      const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
-      let errorMessage = errorCodeToString(returnCode);
-
-      if (returnCode === 0x6a80 || returnCode === 0x6984) {
-        errorMessage = `${errorMessage} : ${response.slice(0, response.length - 2).toString("ascii")}`;
-      }
-
-      let signature: any = null;
-      if (response.length > 2) {
-        signature = response.slice(0, response.length - 2);
-      }
-
-      return { error_message: errorMessage, return_code: returnCode, signature };
-    }, processErrorResponse);
-}
-
-function compressPublicKey(publicKey: Buffer) {
-  if (publicKey.length !== 65) {
-    throw new SwapKitError("wallet_ledger_invalid_params", {
-      reason: "decompressed public key length should be 65 bytes",
-    });
-  }
-  const y = publicKey.slice(33, 65);
-
-  // @ts-expect-error
-  const z = Buffer.from([2 + (y[y.length - 1] & 1)]);
-  return Buffer.concat([z, publicKey.slice(1, 33)]);
-}
-
-export function publicKeyv1(app: any, data: Buffer) {
-  return app.transport
-    .send(CLA, INS.INS_PUBLIC_KEY_SECP256K1, 0, 0, data, [ERROR_CODE.NoError])
-    .then((response: any) => {
-      const errorCodeData = response.slice(-2);
-      const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
-      const pk = Buffer.from(response.slice(0, 65));
-
-      return {
-        compressed_pk: compressPublicKey(pk),
-        error_message: errorCodeToString(returnCode),
-        pk,
-        return_code: returnCode,
-      };
-    }, processErrorResponse);
-}
-
-export function serializePathv2(path: number[]) {
-  if (!path || path.length !== 5) {
-    throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Path must be exactly 5 elements" });
-  }
-
-  const buf = Buffer.alloc(20);
-  // @ts-expect-error
-  buf.writeUInt32LE(0x80000000 + path[0], 0);
-  // @ts-expect-error
-  buf.writeUInt32LE(0x80000000 + path[1], 4);
-  // @ts-expect-error
-  buf.writeUInt32LE(0x80000000 + path[2], 8);
-  // @ts-expect-error
-  buf.writeUInt32LE(path[3], 12);
-  // @ts-expect-error
-  buf.writeUInt32LE(path[4], 16);
-
-  return buf;
-}
-
-export function signSendChunkv2(app: any, chunkIdx: number, chunkNum: number, chunk: Buffer, txType = P2_VALUES.JSON) {
-  let payloadType = PAYLOAD_TYPE.ADD;
-  if (chunkIdx === 1) {
-    payloadType = PAYLOAD_TYPE.INIT;
-  }
-  if (chunkIdx === chunkNum) {
-    payloadType = PAYLOAD_TYPE.LAST;
-  }
-
-  return signSendChunkv1(app, payloadType, 0, chunk, txType);
-}
-
-export function publicKeyv2(app: any, data: Buffer) {
-  return app.transport.send(CLA, INS.GET_ADDR_SECP256K1, 0, 0, data, [ERROR_CODE.NoError]).then((response: any) => {
-    const errorCodeData = response.slice(-2);
-    const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
-    const compressedPk = Buffer.from(response.slice(0, 33));
-
-    return {
-      compressed_pk: compressedPk,
-      error_message: errorCodeToString(returnCode),
-      pk: "OBSOLETE PROPERTY",
-      return_code: returnCode,
-    };
-  }, processErrorResponse);
-}

package/src/ledger/clients/thorchain/index.ts

@@ -1,87 +0,0 @@
-import { base64 } from "@scure/base";
-import { type DerivationPathArray, NetworkDerivationPath, SwapKitError } from "@swapkit/helpers";
-
-import { CosmosLedgerInterface } from "../../interfaces/CosmosLedgerInterface";
-import type { GetAddressAndPubKeyResponse } from "../../types";
-import { getSignature } from "./utils";
-
-export class THORChainLedger extends CosmosLedgerInterface {
-  private pubKey: string | null = null;
-
-  derivationPath: DerivationPathArray;
-
-  constructor(derivationPath: DerivationPathArray = NetworkDerivationPath.THOR) {
-    super();
-    this.chain = "thor";
-    this.derivationPath = derivationPath;
-  }
-
-  get pubkey() {
-    return this.pubKey;
-  }
-
-  connect = async () => {
-    await this.checkOrCreateTransportAndLedger();
-    const { compressed_pk, bech32_address }: GetAddressAndPubKeyResponse = await this.getAddressAndPubKey();
-
-    this.pubKey = base64.encode(compressed_pk);
-
-    return bech32_address;
-  };
-
-  getAddressAndPubKey = async () => {
-    await this.checkOrCreateTransportAndLedger(true);
-
-    const response: GetAddressAndPubKeyResponse = await this.ledgerApp.getAddressAndPubKey(
-      this.derivationPath,
-      this.chain,
-    );
-
-    this.validateResponse(response.return_code, response.error_message);
-
-    return response;
-  };
-
-  showAddressAndPubKey = async () => {
-    await this.checkOrCreateTransportAndLedger(true);
-
-    const response: GetAddressAndPubKeyResponse = await this.ledgerApp.showAddressAndPubKey(
-      this.derivationPath,
-      this.chain,
-    );
-
-    this.validateResponse(response.return_code, response.error_message);
-
-    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: getSignature(signature),
-      },
-    ];
-  };
-
-  sign = async (message: string) => {
-    await this.checkOrCreateTransportAndLedger(true);
-
-    const { return_code, error_message, signature } = await this.ledgerApp.sign(this.derivationPath, message);
-
-    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
-
-    this.validateResponse(return_code, error_message);
-
-    return getSignature(signature);
-  };
-}