@swapkit/wallets 4.0.0-beta.54 → 4.0.0-beta.55

package/src/ledger/clients/evm.ts

@@ -1,183 +0,0 @@
-import type EthereumApp from "@ledgerhq/hw-app-eth";
-import {
-  ChainId,
-  type DerivationPathArray,
-  NetworkDerivationPath,
-  SwapKitError,
-  derivationPathToString,
-} 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({
-      provider,
-      derivationPath: this.derivationPath,
-      chainId: this.chainId,
-    });
-
-  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(),
-      value: tx.value,
-      type: tx.type && !Number.isNaN(tx.type) ? tx.type : tx.maxFeePerGas ? 2 : 0,
-    };
-
-    // 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,
-      {},
-      { externalPlugins: true, erc20: 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: { v: Number(BigInt(v)), r: `0x${r}`, s: `0x${s}` },
-    }).serialized;
-  };
-}
-
-type LedgerParams = { provider: Provider; derivationPath?: DerivationPathArray };
-
-export const EthereumLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.Ethereum, provider, derivationPath });
-
-export const AvalancheLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.Avalanche, provider, derivationPath });
-
-export const BinanceSmartChainLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.BinanceSmartChain, provider, derivationPath });
-
-export const ArbitrumLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.Arbitrum, provider, derivationPath });
-
-export const PolygonLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.Polygon, provider, derivationPath });
-
-export const OptimismLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.Optimism, provider, derivationPath });
-
-export const BaseLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.Base, provider, derivationPath });
-
-export const AuroraLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.Aurora, provider, derivationPath });
-
-export const GnosisLedger = ({ provider, derivationPath }: LedgerParams) =>
-  new EVMLedgerInterface({ chainId: ChainId.Gnosis, provider, derivationPath });

package/src/ledger/clients/near.ts

@@ -1,86 +0,0 @@
-import type Transport from "@ledgerhq/hw-transport";
-import type { DerivationPathArray } from "@swapkit/helpers";
-import type { NearSigner } from "@swapkit/toolboxes/near";
-import type { SignedTransaction, Transaction } from "near-api-js/lib/transaction";
-
-export async function getNearLedgerClient(
-  transport: Transport,
-  derivationPath?: DerivationPathArray,
-) {
-  const Near = await import("@ledgerhq/hw-app-near");
-  const { Chain, DerivationPath, derivationPathToString, SwapKitError } = await import(
-    "@swapkit/helpers"
-  );
-  const nearApp = new Near.default(transport);
-
-  // NEAR uses m/44'/397'/0'/0'/0' by default
-  const path = derivationPath ? derivationPathToString(derivationPath) : DerivationPath[Chain.Near];
-
-  // Get address and public key from Ledger
-  const { address, publicKey: pubKeyHex } = await nearApp.getAddress(path);
-
-  const signer = {
-    async getPublicKey() {
-      const { utils } = await import("near-api-js");
-      // Convert hex public key to NEAR PublicKey format
-      return utils.PublicKey.fromString(`ed25519:${pubKeyHex}`);
-    },
-
-    signNep413Message(
-      _message: string,
-      _accountId: string,
-      _recipient: string,
-      _nonce: Uint8Array,
-      _callbackUrl?: string,
-    ) {
-      // Most NEAR Ledger apps don't support arbitrary message signing
-      return Promise.reject(
-        new SwapKitError("wallet_ledger_method_not_supported", {
-          wallet: "Ledger",
-          method: "signNep413Message",
-        }),
-      );
-    },
-
-    getAddress() {
-      return Promise.resolve(address);
-    },
-
-    async signTransaction(transaction: Transaction) {
-      const { Signature, SignedTransaction } = await import("near-api-js/lib/transaction");
-      try {
-        const signatureArray = await nearApp.signTransaction(transaction.encode(), path);
-        if (!signatureArray) {
-          throw new Error("Signature undefined");
-        }
-
-        const signature = new Signature({
-          keyType: 0,
-          data: signatureArray,
-        });
-
-        const signedTransaction = new SignedTransaction({ transaction, signature });
-
-        return [signatureArray, signedTransaction] as [
-          Uint8Array<ArrayBufferLike>,
-          SignedTransaction,
-        ];
-      } catch (error) {
-        throw new SwapKitError("wallet_ledger_signing_error", {
-          error,
-        });
-      }
-    },
-
-    signDelegateAction(_delegateAction: any) {
-      return Promise.reject(
-        new SwapKitError("wallet_ledger_method_not_supported", {
-          wallet: "Ledger",
-          method: "signDelegateAction",
-        }),
-      );
-    },
-  };
-
-  return signer as NearSigner;
-}

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

@@ -1,117 +0,0 @@
-export const CLA = 0x55;
-export const CHUNK_SIZE = 250;
-export const APP_KEY = "CSM";
-
-export const INS = {
-  GET_VERSION: 0x00,
-  INS_PUBLIC_KEY_SECP256K1: 0x01, // Obsolete
-  SIGN_SECP256K1: 0x02,
-  GET_ADDR_SECP256K1: 0x04,
-};
-
-export const PAYLOAD_TYPE = {
-  INIT: 0x00,
-  ADD: 0x01,
-  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",
-  36864: "No errors",
-  36865: "Device is busy",
-  26626: "Error deriving keys",
-  25600: "Execution Error",
-  26368: "Wrong Length",
-  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",
-};
-
-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.prototype.hasOwnProperty.call(response, "statusCode")) {
-        return {
-          return_code: response.statusCode,
-          error_message: errorCodeToString(response.statusCode),
-        };
-      }
-
-      if (
-        Object.prototype.hasOwnProperty.call(response, "return_code") &&
-        Object.prototype.hasOwnProperty.call(response, "error_message")
-      ) {
-        return response;
-      }
-    }
-    return {
-      return_code: 0xffff,
-      error_message: response.toString(),
-    };
-  }
-
-  return {
-    return_code: 0xffff,
-    error_message: response.toString(),
-  };
-}
-
-export async 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 {
-      return_code: returnCode,
-      error_message: errorCodeToString(returnCode),
-      // ///
-      test_mode: response[0] !== 0,
-      major: response[1],
-      minor: response[2],
-      patch: response[3],
-      device_locked: response[4] === 1,
-      target_id: targetId.toString(16),
-    };
-  }, processErrorResponse);
-}

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

@@ -1,149 +0,0 @@
-import { SwapKitError } from "@swapkit/helpers";
-import {
-  CLA,
-  ERROR_CODE,
-  INS,
-  P2_VALUES,
-  PAYLOAD_TYPE,
-  errorCodeToString,
-  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 async 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 {
-        signature,
-        return_code: returnCode,
-        error_message: errorMessage,
-      };
-    }, 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-ignore
-  const z = Buffer.from([2 + (y[y.length - 1] & 1)]);
-  // @ts-ignore
-  return Buffer.concat([z, publicKey.slice(1, 33)]);
-}
-
-export async 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 {
-        pk,
-        compressed_pk: compressPublicKey(pk),
-        return_code: returnCode,
-        error_message: errorCodeToString(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-ignore
-  buf.writeUInt32LE(0x80000000 + path[0], 0);
-  // @ts-ignore
-  buf.writeUInt32LE(0x80000000 + path[1], 4);
-  // @ts-ignore
-  buf.writeUInt32LE(0x80000000 + path[2], 8);
-  // @ts-ignore
-  buf.writeUInt32LE(path[3], 12);
-  // @ts-ignore
-  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 async 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 {
-        pk: "OBSOLETE PROPERTY",
-        compressed_pk: compressedPk,
-        return_code: returnCode,
-        error_message: errorCodeToString(returnCode),
-      };
-    }, processErrorResponse);
-}

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

@@ -1,94 +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);
-  };
-}