@swapkit/wallet-hardware 4.1.42 → 4.2.3

package/src/keepkey/chains/utxo.ts

@@ -0,0 +1,137 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  FeeOption,
+  type GenericTransferParams,
+  SwapKitError,
+  type UTXOChain,
+} from "@swapkit/helpers";
+import type { UTXOToolboxes } from "@swapkit/toolboxes/utxo";
+import type { Psbt } from "bitcoinjs-lib";
+import { bip32ToAddressNList, ChainToKeepKeyName } from "../coins";
+
+interface KeepKeyInputObject {
+  addressNList: number[];
+  scriptType: string;
+  amount: string;
+  vout: number;
+  txid: string;
+  hex: string;
+}
+
+export async function utxoWalletMethods({
+  sdk,
+  chain,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  chain: Exclude<UTXOChain, typeof Chain.Zcash>;
+  derivationPath?: DerivationPathArray;
+}): Promise<
+  UTXOToolboxes[UTXOChain] & {
+    address: string;
+    signTransaction: (psbt: Psbt, inputs: KeepKeyInputObject[], memo?: string) => Promise<string>;
+  }
+> {
+  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 signTransaction = async (psbt: Psbt, inputs: KeepKeyInputObject[], memo = "") => {
+    const outputs = psbt.txOutputs
+      .map((output) => {
+        const { value, address, change } = output as {
+          address: string;
+          script: Buffer;
+          value: number;
+          change?: boolean;
+        };
+
+        const outputAddress =
+          // @ts-expect-error - stripToCashAddress is not defined in the UTXO toolbox just only on BCH
+          chain === Chain.BitcoinCash ? toolbox.stripToCashAddress(address) : address;
+
+        if (change || address === walletAddress) {
+          return {
+            addressNList: addressInfo.address_n,
+            addressType: "change",
+            amount: value,
+            isChange: true,
+            scriptType,
+          };
+        }
+
+        if (outputAddress) {
+          return { address: outputAddress, addressType: "spend", amount: value };
+        }
+
+        return null;
+      })
+      .filter(Boolean);
+
+    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 { psbt, 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(psbt, inputs, memo);
+    return toolbox.broadcastTx(txHex);
+  };
+
+  return { ...toolbox, address: walletAddress, signTransaction, transfer };
+}

package/src/keepkey/coins.ts

@@ -0,0 +1,67 @@
+/*
+    KeepKey Specific bip32 path conventions
+*/
+
+import { SwapKitError } from "@swapkit/helpers";
+
+const HARDENED = 0x80000000;
+
+export enum ChainToKeepKeyName {
+  BTC = "Bitcoin",
+  BCH = "BitcoinCash",
+  DOGE = "Dogecoin",
+  LTC = "Litecoin",
+  DASH = "Dash",
+  XRP = "Ripple",
+}
+
+export function addressNListToBIP32(address: number[]) {
+  return `m/${address.map((num) => (num >= HARDENED ? `${num - HARDENED}'` : num)).join("/")}`;
+}
+
+export function bip32Like(path: string) {
+  if (path === "m/") return true;
+
+  return /^m(((\/[0-9]+h)+|(\/[0-9]+H)+|(\/[0-9]+')*)((\/[0-9]+)*))$/.test(path);
+}
+
+export function bip32ToAddressNList(initPath: string): number[] {
+  let path = initPath;
+
+  if (!bip32Like(path)) {
+    throw new SwapKitError("wallet_keepkey_invalid_params", { reason: `Not a bip32 path: '${path}'` });
+  }
+
+  if (/^m\//i.test(path)) {
+    path = path.slice(2);
+  }
+  const segments = path.split("/");
+
+  if (segments.length === 1 && segments[0] === "") return [];
+
+  const ret = new Array(segments.length);
+
+  for (let i = 0; i < segments.length; i++) {
+    // TODO: Check for better way instead of exec
+    const segment = segments[i];
+    if (segment) {
+      const tmp = /(\d+)([hH']?)/.exec(segment);
+      if (tmp === null) throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid input" });
+
+      const [, num = "", modifier = ""] = tmp;
+
+      ret[i] = Number.parseInt(num, 10);
+
+      if (ret[i] >= HARDENED)
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid child index" });
+
+      if (modifier === "h" || modifier === "H" || modifier === "'") {
+        ret[i] += HARDENED;
+      } else if (modifier.length > 0) {
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid modifier" });
+      }
+    }
+  }
+
+  return ret;
+}

package/src/keepkey/index.ts

@@ -0,0 +1,153 @@
+import { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  Chain,
+  type DerivationPathArray,
+  filterSupportedChains,
+  NetworkDerivationPath,
+  SKConfig,
+  SwapKitError,
+  WalletOption,
+} from "@swapkit/helpers";
+
+export type { PairingInfo } from "@keepkey/keepkey-sdk";
+
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+import { cosmosWalletMethods } from "./chains/cosmos";
+import { KeepKeySigner } from "./chains/evm";
+import { mayachainWalletMethods } from "./chains/mayachain";
+import { thorchainWalletMethods } from "./chains/thorchain";
+import { utxoWalletMethods } from "./chains/utxo";
+
+export const keepkeyWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectKeepkey(chains: Chain[], derivationPathMap?: Record<Chain, DerivationPathArray>) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+      const pairingInfo = SKConfig.get("integrations").keepKey;
+      if (!pairingInfo) throw new Error("KeepKey config not found");
+
+      const initialApiKey = SKConfig.get("apiKeys").keepKey || "1234";
+
+      await checkAndLaunch();
+
+      // Conform to the expected { apiKey, pairingInfo } structure
+      const keepkeyConfig = { apiKey: initialApiKey, pairingInfo };
+      const keepKeySdk = await KeepKeySdk.create(keepkeyConfig);
+
+      // Persist the new API key via SKConfig after pairing
+      if (keepkeyConfig.apiKey && keepkeyConfig.apiKey !== initialApiKey) {
+        SKConfig.setApiKey("keepKey", keepkeyConfig.apiKey);
+      }
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const walletMethods = await getWalletMethods({
+            chain,
+            derivationPath: derivationPathMap?.[chain] || NetworkDerivationPath[chain],
+            sdk: keepKeySdk,
+          });
+          const address = (await walletMethods.getAddress()) || "";
+
+          addChain({ ...walletMethods, address, chain, walletType: WalletOption.KEEPKEY });
+        }),
+      );
+      return true;
+    },
+  name: "connectKeepkey",
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.BitcoinCash,
+    Chain.Cosmos,
+    Chain.Dogecoin,
+    Chain.Dash,
+    Chain.Ethereum,
+    Chain.Litecoin,
+    Chain.Ripple,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.THORChain,
+    Chain.Maya,
+    Chain.XLayer,
+  ],
+  walletType: WalletOption.KEEPKEY,
+});
+
+export const KEEPKEY_SUPPORTED_CHAINS = getWalletSupportedChains(keepkeyWallet);
+
+async function getWalletMethods({
+  sdk,
+  chain,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  chain: Chain;
+  derivationPath?: DerivationPathArray;
+}) {
+  const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
+
+  switch (chain) {
+    case Chain.BinanceSmartChain:
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.Avalanche:
+    case Chain.Base:
+    case Chain.Ethereum:
+    case Chain.XLayer: {
+      const provider = await getProvider(chain);
+      const signer = new KeepKeySigner({ chain, derivationPath, provider, sdk });
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
+
+      return toolbox;
+    }
+    case Chain.Cosmos: {
+      return cosmosWalletMethods({ derivationPath, sdk });
+    }
+    case Chain.THORChain: {
+      return thorchainWalletMethods({ derivationPath, sdk });
+    }
+    case Chain.Maya: {
+      return mayachainWalletMethods({ derivationPath, sdk });
+    }
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dash:
+    case Chain.Dogecoin:
+    case Chain.Litecoin: {
+      return utxoWalletMethods({ chain, derivationPath, sdk });
+    }
+    case Chain.Ripple: {
+      const { rippleWalletMethods } = await import("./chains/ripple");
+      return rippleWalletMethods({ derivationPath, sdk });
+    }
+    default:
+      throw new SwapKitError("wallet_keepkey_chain_not_supported", { chain });
+  }
+}
+
+// kk-sdk docs: https://keepkey.com/blog/building_on_the_keepkey_sdk
+// test spec: if offline, launch keepkey-bridge
+async function checkAndLaunch(attempts = 0) {
+  if (attempts >= 3) {
+    alert("KeepKey desktop is required for keepkey-sdk, please go to https://keepkey.com/get-started");
+  }
+  const isAvailable = await checkKeepkeyAvailability();
+
+  if (!isAvailable) {
+    window.location.assign("keepkey://launch");
+    await new Promise((resolve) => setTimeout(resolve, 30000));
+    await checkAndLaunch(attempts + 1);
+  }
+}
+
+async function checkKeepkeyAvailability(spec = "http://localhost:1646/spec/swagger.json") {
+  try {
+    const response = await fetch(spec);
+    return response.status === 200;
+  } catch {
+    return false;
+  }
+}

package/src/ledger/clients/cosmos.ts

@@ -0,0 +1,84 @@
+import {
+  type DerivationPathArray,
+  derivationPathToString,
+  NetworkDerivationPath,
+  SwapKitError,
+} from "@swapkit/helpers";
+import { CosmosLedgerInterface } from "../interfaces/CosmosLedgerInterface";
+
+export class CosmosLedger extends CosmosLedgerInterface {
+  private pubKey: string | null = null;
+
+  derivationPath: string;
+
+  constructor(derivationPath: DerivationPathArray = NetworkDerivationPath.GAIA) {
+    super();
+    this.chain = "cosmos";
+    this.derivationPath = derivationPathToString(derivationPath);
+  }
+
+  connect = async () => {
+    await this.checkOrCreateTransportAndLedger(true);
+    const { publicKey, address } = await this.getAddressAndPubKey();
+
+    this.pubKey = Buffer.from(publicKey, "hex").toString("base64");
+
+    return address;
+  };
+
+  getAddressAndPubKey = async () => {
+    await this.checkOrCreateTransportAndLedger(true);
+
+    const response = await this.ledgerApp.getAddress(this.derivationPath, this.chain);
+
+    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 }];
+  };
+
+  signAmino = async (signerAddress: string, signDoc: any): Promise<any> => {
+    await this.checkOrCreateTransportAndLedger(true);
+
+    const accounts = await this.getAccounts();
+    const accountIndex = accounts.findIndex((account) => account.address === signerAddress);
+
+    if (accountIndex === -1) {
+      throw new SwapKitError("wallet_ledger_address_not_found", { address: signerAddress });
+    }
+
+    const importedAmino = await import("@cosmjs/amino");
+    const encodeSecp256k1Signature =
+      importedAmino.encodeSecp256k1Signature ?? importedAmino.default?.encodeSecp256k1Signature;
+    const serializeSignDoc = importedAmino.serializeSignDoc ?? importedAmino.default?.serializeSignDoc;
+    const importedCrypto = await import("@cosmjs/crypto");
+    const Secp256k1Signature = importedCrypto.Secp256k1Signature ?? importedCrypto.default?.Secp256k1Signature;
+
+    const message = serializeSignDoc(signDoc);
+    const signature = await this.ledgerApp.sign(this.derivationPath, message);
+
+    this.validateResponse(signature.return_code, signature.error_message);
+
+    const secpSignature = Secp256k1Signature.fromDer(signature.signature).toFixedLength();
+
+    return { signature: encodeSecp256k1Signature(accounts[0].pubkey, secpSignature), signed: signDoc };
+  };
+
+  getAccounts = async () => {
+    await this.checkOrCreateTransportAndLedger(true);
+
+    const addressAndPubKey = await this.getAddressAndPubKey();
+    return [
+      { address: addressAndPubKey.address, algo: "secp256k1", pubkey: Buffer.from(addressAndPubKey.publicKey, "hex") },
+    ] as any[];
+  };
+}

package/src/ledger/clients/evm.ts

@@ -0,0 +1,140 @@
+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 XLayerLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.XLayer });

package/src/ledger/clients/near.ts

@@ -0,0 +1,63 @@
+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;
+}