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

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

@@ -1,300 +0,0 @@
-import type Transport from "@ledgerhq/hw-transport";
-import { SwapKitError } from "@swapkit/helpers";
-/** ******************************************************************************
- *  (c) 2019 ZondaX GmbH
- *  (c) 2016-2017 Ledger
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- ******************************************************************************* */
-
-import {
-  CHUNK_SIZE,
-  CLA,
-  ERROR_CODE,
-  INS,
-  P1_VALUES,
-  P2_VALUES,
-  errorCodeToString,
-  getVersion,
-  processErrorResponse,
-} from "./common";
-import {
-  publicKeyv1,
-  publicKeyv2,
-  serializePathv1,
-  serializePathv2,
-  signSendChunkv1,
-  signSendChunkv2,
-} from "./helpers";
-
-export class THORChainApp {
-  transport: Transport;
-  versionResponse: any;
-
-  constructor(transport: any) {
-    if (!transport) {
-      throw new SwapKitError("wallet_ledger_transport_not_defined");
-    }
-
-    this.transport = transport;
-  }
-
-  static serializeHRP(hrp: string) {
-    if (hrp == null || hrp.length < 3 || hrp.length > 83) {
-      throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Invalid HRP" });
-    }
-    const buf = Buffer.alloc(1 + hrp.length);
-    buf.writeUInt8(hrp.length, 0);
-    buf.write(hrp, 1);
-    return buf;
-  }
-
-  async serializePath(path: number[]) {
-    this.versionResponse = await getVersion(this.transport);
-
-    if (this.versionResponse.return_code !== ERROR_CODE.NoError) {
-      throw this.versionResponse;
-    }
-
-    switch (this.versionResponse.major) {
-      case 1:
-        return serializePathv1(path);
-      case 2:
-        return serializePathv2(path);
-      default:
-        return Buffer.alloc(0);
-    }
-  }
-
-  async signGetChunks(path: number[], buffer: Buffer) {
-    const serializedPath = await this.serializePath(path);
-
-    const chunks = [];
-    chunks.push(serializedPath);
-
-    for (let i = 0; i < buffer.length; i += CHUNK_SIZE) {
-      let end = i + CHUNK_SIZE;
-      if (i > buffer.length) {
-        end = buffer.length;
-      }
-      chunks.push(buffer.slice(i, end));
-    }
-
-    return chunks;
-  }
-
-  async getVersion() {
-    try {
-      this.versionResponse = await getVersion(this.transport);
-      return this.versionResponse;
-    } catch (e) {
-      return processErrorResponse(e);
-    }
-  }
-
-  async appInfo() {
-    return this.transport.send(0xb0, 0x01, 0, 0).then((response: any) => {
-      const errorCodeData = response.slice(-2);
-      const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
-
-      let appName = "";
-      let appVersion = "";
-      let flagLen = 0;
-      let flagsValue = 0;
-
-      if (response[0] !== 1) {
-        // Ledger responds with format ID 1. There is no spec for any format != 1
-        return {
-          return_code: 0x9001,
-          error_message: "response format ID not recognized",
-        };
-      }
-
-      const appNameLen = response[1];
-      appName = response.slice(2, 2 + appNameLen).toString("ascii");
-      let idx = 2 + appNameLen;
-      const appVersionLen = response[idx];
-      idx += 1;
-      appVersion = response.slice(idx, idx + appVersionLen).toString("ascii");
-      idx += appVersionLen;
-      const appFlagsLen = response[idx];
-      idx += 1;
-      flagLen = appFlagsLen;
-      flagsValue = response[idx];
-
-      return {
-        return_code: returnCode,
-        error_message: errorCodeToString(returnCode),
-        appName,
-        appVersion,
-        flagLen,
-        flagsValue,
-        flag_recovery: (flagsValue & 1) !== 0,
-        flag_signed_mcu_code: (flagsValue & 2) !== 0,
-        flag_onboarded: (flagsValue & 4) !== 0,
-        flag_pin_validated: (flagsValue & 128) !== 0,
-      };
-    }, processErrorResponse);
-  }
-
-  async deviceInfo() {
-    return this.transport
-      .send(0xe0, 0x01, 0, 0, Buffer.from([]), [ERROR_CODE.NoError, 0x6e00])
-      .then((response: any) => {
-        const errorCodeData = response.slice(-2);
-        const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
-
-        if (returnCode === 0x6e00) {
-          return {
-            return_code: returnCode,
-            error_message: "This command is only available in the Dashboard",
-          };
-        }
-
-        const targetId = response.slice(0, 4).toString("hex");
-
-        let pos = 4;
-        const secureElementVersionLen = response[pos];
-        pos += 1;
-        const seVersion = response.slice(pos, pos + secureElementVersionLen).toString();
-        pos += secureElementVersionLen;
-
-        const flagsLen = response[pos];
-        pos += 1;
-        const flag = response.slice(pos, pos + flagsLen).toString("hex");
-        pos += flagsLen;
-
-        const mcuVersionLen = response[pos];
-        pos += 1;
-        // Patch issue in mcu version
-        let tmp = response.slice(pos, pos + mcuVersionLen);
-        if (tmp[mcuVersionLen - 1] === 0) {
-          tmp = response.slice(pos, pos + mcuVersionLen - 1);
-        }
-        const mcuVersion = tmp.toString();
-
-        return {
-          return_code: returnCode,
-          error_message: errorCodeToString(returnCode),
-          // //
-          targetId,
-          seVersion,
-          flag,
-          mcuVersion,
-        };
-      }, processErrorResponse);
-  }
-
-  async publicKey(path: number[]) {
-    try {
-      const serializedPath = await this.serializePath(path);
-
-      switch (this.versionResponse.major) {
-        case 1:
-          return publicKeyv1(this, serializedPath);
-        case 2: {
-          // @ts-ignore
-          const data = Buffer.concat([THORChainApp.serializeHRP("thor"), serializedPath]);
-          return publicKeyv2(this, data);
-        }
-        default:
-          return {
-            return_code: 0x6400,
-            error_message: "App Version is not supported",
-          };
-      }
-    } catch (e) {
-      return processErrorResponse(e);
-    }
-  }
-
-  async getAddressAndPubKey(path: number[], hrp: string, showInDevice = false) {
-    return this.serializePath(path)
-      .then((serializedPath: Buffer) => {
-        // @ts-ignore
-        const data = Buffer.concat([THORChainApp.serializeHRP(hrp), serializedPath]);
-        return this.transport
-          .send(
-            CLA,
-            INS.GET_ADDR_SECP256K1,
-            showInDevice ? P1_VALUES.SHOW_ADDRESS_IN_DEVICE : P1_VALUES.ONLY_RETRIEVE,
-            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));
-            const bech32Address = Buffer.from(response.slice(33, -2)).toString();
-
-            return {
-              bech32_address: bech32Address,
-              compressed_pk: compressedPk,
-              return_code: returnCode,
-              error_message: errorCodeToString(returnCode),
-            };
-          }, processErrorResponse);
-      })
-      .catch((err) => processErrorResponse(err));
-  }
-
-  showAddressAndPubKey(path: number[], hrp: string) {
-    return this.getAddressAndPubKey(path, hrp, true);
-  }
-
-  signSendChunk(chunkIdx: number, chunkNum: number, chunk: Buffer, txType = P2_VALUES.JSON) {
-    switch (this.versionResponse.major) {
-      case 1:
-        return signSendChunkv1(this, chunkIdx, chunkNum, chunk, txType);
-      case 2:
-        return signSendChunkv2(this, chunkIdx, chunkNum, chunk, txType);
-      default:
-        return {
-          return_code: 0x6400,
-          error_message: "App Version is not supported",
-        };
-    }
-  }
-
-  async sign(path: number[], message: string, txType = P2_VALUES.JSON) {
-    const buffer = Buffer.from(message);
-    let chunks: Buffer[] = [];
-    let response: any;
-    try {
-      chunks = await this.signGetChunks(path, buffer);
-      response = await this.signSendChunk(1, chunks.length, chunks[0] as Buffer, txType);
-    } catch (error) {
-      processErrorResponse(error);
-    }
-    let result = {
-      return_code: response.return_code,
-      error_message: response.error_message,
-      signature: null,
-    };
-
-    for (let i = 1; i < chunks.length; i += 1) {
-      result = await this.signSendChunk(1 + i, chunks.length, chunks[i] as Buffer, txType);
-      if (result.return_code !== ERROR_CODE.NoError) {
-        break;
-      }
-    }
-
-    return {
-      return_code: result.return_code,
-      error_message: result.error_message,
-      signature: result.signature,
-    };
-  }
-}

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

@@ -1,76 +0,0 @@
-import { base64 } from "@scure/base";
-import { SwapKitError } from "@swapkit/helpers";
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: any: refactor
-export const getSignature = (signatureArray: any) => {
-  // Check Type Length Value encoding
-  if (signatureArray.length < 64) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", { reason: "Too short" });
-  }
-  if (signatureArray[0] !== 0x30) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", {
-      reason: "TLV encoding: expected first byte 0x30",
-    });
-  }
-  if (signatureArray[1] + 2 !== signatureArray.length) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", {
-      reason: "signature length does not match TLV",
-    });
-  }
-  if (signatureArray[2] !== 0x02) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", {
-      reason: "TLV encoding: expected length type 0x02",
-    });
-  }
-
-  // r signature
-  const rLength = signatureArray[3];
-  let rSignature = signatureArray.slice(4, rLength + 4);
-
-  // Drop leading zero on some 'r' signatures that are 33 bytes.
-  if (rSignature.length === 33 && rSignature[0] === 0) {
-    rSignature = rSignature.slice(1, 33);
-  } else if (rSignature.length === 33) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", { reason: "r too long" });
-  }
-
-  // add leading zero's to pad to 32 bytes
-  while (rSignature.length < 32) {
-    rSignature.unshift(0);
-  }
-
-  // s signature
-  if (signatureArray[rLength + 4] !== 0x02) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", {
-      reason: "TLV encoding: expected length type 0x02 for s",
-    });
-  }
-
-  const sLength = signatureArray[rLength + 5];
-
-  if (4 + rLength + 2 + sLength !== signatureArray.length) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", {
-      reason: "TLV byte lengths do not match message length",
-    });
-  }
-
-  let sSignature = signatureArray.slice(rLength + 6, signatureArray.length);
-
-  // Drop leading zero on 's' signatures that are 33 bytes. This shouldn't occur since ledger signs using "Small s" math. But just to be sure...
-  if (sSignature.length === 33 && sSignature[0] === 0) {
-    sSignature = sSignature.slice(1, 33);
-  } else if (sSignature.length === 33) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", { reason: "s too long" });
-  }
-
-  // add leading zero's to pad to 32 bytes
-  while (sSignature.length < 32) {
-    sSignature.unshift(0);
-  }
-
-  if (rSignature.length !== 32 || sSignature.length !== 32) {
-    throw new SwapKitError("wallet_ledger_invalid_signature", { reason: "must be 32 bytes each" });
-  }
-
-  return base64.encode(Buffer.concat([rSignature, sSignature]));
-};

package/src/ledger/clients/tron.ts

@@ -1,92 +0,0 @@
-import type TronApp from "@ledgerhq/hw-app-trx";
-import {
-  type DerivationPathArray,
-  NetworkDerivationPath,
-  SwapKitError,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import type { TronSigner, TronTransaction } from "@swapkit/toolboxes/tron";
-
-import { getLedgerTransport } from "../helpers/getLedgerTransport";
-
-export class TronLedgerInterface implements TronSigner {
-  derivationPath: string;
-  ledgerApp: InstanceType<typeof TronApp> | null = null;
-  ledgerTimeout = 50000;
-
-  constructor(derivationPath?: DerivationPathArray | string) {
-    this.derivationPath =
-      typeof derivationPath === "string"
-        ? derivationPath
-        : derivationPathToString(derivationPath || NetworkDerivationPath.TRX);
-  }
-
-  checkOrCreateTransportAndLedger = async () => {
-    if (this.ledgerApp) return;
-    await this.createTransportAndLedger();
-  };
-
-  createTransportAndLedger = async () => {
-    const transport = await getLedgerTransport();
-    const TronApp = (await import("@ledgerhq/hw-app-trx")).default;
-
-    this.ledgerApp = new TronApp(transport);
-  };
-
-  getAddress = async (): Promise<string> => {
-    const response = await this.getAddressAndPubKey();
-    if (!response) throw new SwapKitError("wallet_ledger_failed_to_get_address");
-    return response.address;
-  };
-
-  getAddressAndPubKey = async () => {
-    await this.createTransportAndLedger();
-    const result = await this.ledgerApp?.getAddress(this.derivationPath);
-
-    if (!result) throw new SwapKitError("wallet_ledger_failed_to_get_address");
-
-    return {
-      address: result.address,
-      publicKey: result.publicKey,
-    };
-  };
-
-  showAddressAndPubKey = async () => {
-    await this.createTransportAndLedger();
-    return this.ledgerApp?.getAddress(this.derivationPath, true);
-  };
-
-  signTransaction = async (transaction: TronTransaction) => {
-    await this.createTransportAndLedger();
-
-    if (!this.ledgerApp) {
-      throw new SwapKitError("wallet_ledger_transport_error");
-    }
-
-    // Tron transactions need to be serialized before signing
-    const serializedTx = JSON.stringify(transaction);
-
-    try {
-      const signature = await this.ledgerApp.signTransaction(
-        this.derivationPath,
-        serializedTx,
-        [], // Token signatures array - empty for native TRX transfers
-      );
-
-      if (!signature) {
-        throw new SwapKitError("wallet_ledger_signing_error");
-      }
-
-      // Return the signed transaction in Tron's expected format
-      return {
-        ...transaction,
-        signature: [signature],
-      };
-    } catch (error) {
-      throw new SwapKitError("wallet_ledger_signing_error", { error });
-    }
-  };
-}
-
-export const TronLedger = (derivationPath?: DerivationPathArray) =>
-  new TronLedgerInterface(derivationPath);

package/src/ledger/clients/utxo.ts

@@ -1,148 +0,0 @@
-import type BitcoinApp from "@ledgerhq/hw-app-btc";
-import type { CreateTransactionArg } from "@ledgerhq/hw-app-btc/lib-es/createTransaction";
-import {
-  type DerivationPathArray,
-  SwapKitError,
-  derivationPathToString,
-  getWalletFormatFor,
-} from "@swapkit/helpers";
-import type { UTXOType } from "@swapkit/toolboxes/utxo";
-import { type Psbt, Transaction } from "bitcoinjs-lib";
-
-import { getLedgerTransport } from "../helpers/getLedgerTransport";
-
-type Params = {
-  psbt: Psbt;
-  inputUtxos: UTXOType[];
-  btcApp: any;
-  derivationPath: string;
-};
-
-const signUTXOTransaction = async (
-  { psbt, inputUtxos, btcApp, derivationPath }: Params,
-  options?: Partial<CreateTransactionArg>,
-) => {
-  const inputs = inputUtxos.map((item) => {
-    const utxoTx = Transaction.fromHex(item.txHex || "");
-    const splitTx = btcApp.splitTransaction(utxoTx.toHex(), utxoTx.hasWitnesses());
-
-    return [
-      splitTx,
-      item.index,
-      undefined as string | null | undefined,
-      undefined as number | null | undefined,
-    ] as any;
-  });
-
-  const newTxHex = psbt.data.globalMap.unsignedTx.toBuffer().toString("hex");
-
-  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 });
-};
-
-const BaseLedgerUTXO = ({
-  chain,
-  additionalSignParams,
-}: {
-  chain: "bitcoin-cash" | "bitcoin" | "litecoin" | "dogecoin" | "dash";
-  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({ checkBtcApp, btcApp })}`,
-      });
-    }
-
-    transport ||= await getLedgerTransport();
-  }
-
-  async function createTransportWebUSB() {
-    transport = await getLedgerTransport();
-    const BitcoinApp = (await import("@ledgerhq/hw-app-btc")).default;
-
-    btcApp = new BitcoinApp({ transport, currency: chain });
-  }
-
-  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({ transport, currency: chain });
-      },
-      getExtendedPublicKey: async (path = "84'/0'/0'", xpubVersion = 76067358) => {
-        await checkBtcAppAndCreateTransportWebUSB(false);
-
-        return btcApp.getWalletXpub({ path, xpubVersion });
-      },
-      signTransaction: async (psbt: Psbt, inputUtxos: UTXOType[]) => {
-        await createTransportWebUSB();
-
-        return signUTXOTransaction(
-          { psbt, derivationPath, btcApp, inputUtxos },
-          additionalSignParams,
-        );
-      },
-      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;
-      },
-    };
-  };
-};
-
-export const BitcoinLedger = BaseLedgerUTXO({ chain: "bitcoin" });
-export const LitecoinLedger = BaseLedgerUTXO({ chain: "litecoin" });
-
-export const BitcoinCashLedger = BaseLedgerUTXO({
-  chain: "bitcoin-cash",
-  additionalSignParams: { segwit: false, additionals: ["abc"], sigHashType: 0x41 },
-});
-
-export const DogecoinLedger = BaseLedgerUTXO({
-  chain: "dogecoin",
-  additionalSignParams: { additionals: [], segwit: false, useTrustedInputForSegwit: false },
-});
-
-export const DashLedger = BaseLedgerUTXO({
-  chain: "dash",
-  additionalSignParams: { additionals: [], segwit: false, useTrustedInputForSegwit: false },
-});

package/src/ledger/clients/xrp.ts

@@ -1,66 +0,0 @@
-import type Xrp from "@ledgerhq/hw-app-xrp";
-import type Transport from "@ledgerhq/hw-transport";
-import {
-  Chain,
-  type DerivationPathArray,
-  NetworkDerivationPath,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import type { Transaction } from "@swapkit/toolboxes/ripple";
-import { encode } from "ripple-binary-codec";
-import type { Payment } from "xrpl";
-import { getLedgerTransport } from "../helpers";
-
-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;
-}
-
-async function establishConnection(transport: Transport) {
-  const { default: Xrp } = await import("@ledgerhq/hw-app-xrp");
-  return new Xrp(transport);
-}
-
-function fetchAddressAndPublicKey({
-  instance,
-  derivationPath,
-}: { instance: Xrp; derivationPath: string }) {
-  return instance.getAddress(derivationPath);
-}
-
-export const XRPLedger = async (derivationPath?: DerivationPathArray) => {
-  const path = derivationPathToString(derivationPath || NetworkDerivationPath[Chain.Ripple]);
-  const transport = await getLedgerTransport();
-  const xrpInstance = await establishConnection(transport);
-
-  const { address, publicKey } = await fetchAddressAndPublicKey({
-    instance: xrpInstance,
-    derivationPath: path,
-  });
-
-  async function sign(transaction: Payment | Transaction) {
-    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 { tx_blob, hash };
-  }
-
-  return { address, sign };
-};