@swapkit/wallets 3.0.0-beta.9 → 4.0.0-beta.39

package/src/keepkey/index.ts

@@ -3,6 +3,7 @@ import {
   type DerivationPathArray,
   NetworkDerivationPath,
   SKConfig,
+  SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
@@ -32,6 +33,7 @@ export const keepkeyWallet = createWallet({
     Chain.Dash,
     Chain.Ethereum,
     Chain.Litecoin,
+    Chain.Ripple,
     Chain.Optimism,
     Chain.Polygon,
     Chain.THORChain,
@@ -44,15 +46,22 @@ export const keepkeyWallet = createWallet({
       derivationPathMap?: Record<Chain, DerivationPathArray>,
     ) {
       const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const config = SKConfig.get("integrations").keepKey;
+      const pairingInfo = SKConfig.get("integrations").keepKey;
+      if (!pairingInfo) throw new Error("KeepKey config not found");
 
-      if (!config) throw new Error("KeepKey config not found");
+      const initialApiKey = SKConfig.get("apiKeys").keepKey || "1234";
 
       await checkAndLaunch();
 
-      const keepkeyConfig = { ...config, apiKey: SKConfig.get("apiKeys").keepKey };
+      // 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({
@@ -84,6 +93,7 @@ async function getWalletMethods({
     case Chain.Optimism:
     case Chain.Polygon:
     case Chain.Avalanche:
+    case Chain.Base:
     case Chain.Ethereum: {
       const provider = await getProvider(chain);
       const signer = new KeepKeySigner({ sdk, chain, derivationPath, provider });
@@ -107,12 +117,16 @@ async function getWalletMethods({
     case Chain.Litecoin: {
       return utxoWalletMethods({ sdk, chain, derivationPath });
     }
+    case Chain.Ripple: {
+      const { rippleWalletMethods } = await import("./chains/ripple");
+      return rippleWalletMethods({ sdk, derivationPath });
+    }
     default:
-      throw new Error(`Chain not supported ${chain}`);
+      throw new SwapKitError("wallet_keepkey_chain_not_supported", { chain });
   }
 }
 
-// kk-sdk docs: https://medium.com/@highlander_35968/building-on-the-keepkey-sdk-2023fda41f38
+// 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) {
@@ -133,8 +147,7 @@ async function checkKeepkeyAvailability(spec = "http://localhost:1646/spec/swagg
   try {
     const response = await fetch(spec);
     return response.status === 200;
-  } catch (error) {
-    console.error(error);
+  } catch (_error) {
     return false;
   }
 }

package/src/keepkey-bex/index.ts

@@ -36,6 +36,7 @@ export const keepkeyBexWallet = createWallet({
     Chain.Maya,
     Chain.Optimism,
     Chain.Polygon,
+    Chain.Ripple,
     Chain.Solana,
     Chain.THORChain,
   ],
@@ -83,11 +84,11 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
 
       // @ts-expect-error assumed available connection
       const signer = window.keepkey?.cosmos?.getOfflineSignerOnlyAmino(ChainIdToChain[chain]);
-      if (!signer) throw new Error("Could not load signer");
+      if (!signer) throw new SwapKitError("wallet_keepkey_signer_not_found");
       const toolbox = getCosmosToolbox(chain, { signer });
 
       const accounts = await signer.getAccounts();
-      if (!accounts?.[0]?.address) throw new Error("No accounts found");
+      if (!accounts?.[0]?.address) throw new SwapKitError("wallet_keepkey_no_accounts");
 
       const [{ address }] = accounts;
 
@@ -103,18 +104,13 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
       const toolbox = await getUtxoToolbox(chain);
 
       const getBalance = async () => {
-        try {
-          const providerChain = getProviderNameFromChain(chain);
-          // @ts-expect-error We assuming there chains via switch
-          const balance = await window?.keepkey?.[providerChain]?.request({
-            method: "request_balance",
-          });
-          const assetValue = AssetValue.from({ chain, value: balance[0].balance });
-          return [assetValue];
-        } catch (error) {
-          console.error("Error fetching balance:", error);
-          throw error;
-        }
+        const providerChain = getProviderNameFromChain(chain);
+        // @ts-expect-error We assuming there chains via switch
+        const balance = await window?.keepkey?.[providerChain]?.request({
+          method: "request_balance",
+        });
+        const assetValue = AssetValue.from({ chain, value: balance[0].balance });
+        return [assetValue];
       };
 
       return { ...toolbox, getBalance, transfer: walletTransfer };

package/src/keepkey-bex/walletHelpers.ts

@@ -60,7 +60,7 @@ export const getProviderNameFromChain = (chain: Chain): string => {
     case Chain.Litecoin:
       return "litecoin";
     default:
-      throw new Error("Unsupported chain");
+      throw new SwapKitError("wallet_keepkey_chain_not_supported", { chain });
   }
 };
 

package/src/keplr/index.ts

@@ -2,6 +2,7 @@ import {
   Chain,
   ChainId,
   ChainToChainId,
+  SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
@@ -28,19 +29,19 @@ export const keplrWallet = createWallet({
 
           if (!keplrSupportedChainIds.includes(chainId)) {
             const chainConfig = chainRegistry.get(chainId);
-            if (!chainConfig) throw new Error(`Unsupported chain ${chain}`);
+            if (!chainConfig) throw new SwapKitError("wallet_keplr_chain_not_supported", { chain });
 
             await keplrClient.experimentalSuggestChain(chainConfig);
           }
 
           keplrClient?.enable(chainId);
           const signer = keplrClient?.getOfflineSignerOnlyAmino(chainId);
-          if (!signer) throw new Error("Could not load signer");
+          if (!signer) throw new SwapKitError("wallet_keplr_signer_not_found");
 
           const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
 
           const accounts = await signer.getAccounts();
-          if (!accounts?.[0]?.address) throw new Error("No accounts found");
+          if (!accounts?.[0]?.address) throw new SwapKitError("wallet_keplr_no_accounts");
 
           const [{ address }] = accounts;
           const toolbox = getCosmosToolbox(chain, { signer });

package/src/keystore/helpers.ts

@@ -1,3 +1,4 @@
+import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes } from "node:crypto";
 import { generateMnemonic, validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 
@@ -15,7 +16,7 @@ export type Keystore = {
 };
 
 async function blake256(initData: Buffer | string) {
-  const { blake2bFinal, blake2bInit, blake2bUpdate } = await import("blakejs");
+  const { blake2bFinal, blake2bInit, blake2bUpdate } = (await import("blakejs")).default;
   let data = initData;
 
   if (!(data instanceof Buffer)) {
@@ -32,8 +33,6 @@ async function blake256(initData: Buffer | string) {
 }
 
 export async function encryptToKeyStore(phrase: string, password: string) {
-  const { pbkdf2Sync, randomBytes, createCipheriv } = await import("crypto");
-
   const cipher = "aes-128-ctr";
   const iv = randomBytes(16);
   const salt = randomBytes(32);
@@ -71,7 +70,6 @@ export function validatePhrase(phrase: string) {
 }
 
 export async function decryptFromKeystore(keystore: Keystore, password: string) {
-  const { createDecipheriv, pbkdf2Sync } = await import("crypto");
   const { SwapKitError } = await import("@swapkit/helpers");
 
   switch (keystore.version) {

package/src/keystore/index.ts

@@ -23,6 +23,8 @@ export const keystoreWallet = createWallet({
     Chain.Chainflip,
     Chain.Ripple,
     Chain.Solana,
+    Chain.Tron,
+    Chain.Near,
   ],
   connect: ({ addChain, supportedChains, walletType }) =>
     async function connectKeystore(

package/src/ledger/clients/cosmos.ts

@@ -1,6 +1,7 @@
 import {
   type DerivationPathArray,
   NetworkDerivationPath,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import { CosmosLedgerInterface } from "../interfaces/CosmosLedgerInterface";
@@ -41,7 +42,7 @@ export class CosmosLedger extends CosmosLedgerInterface {
       rawTx,
     );
 
-    if (!this.pubKey) throw new Error("Public Key not found");
+    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
 
     this.validateResponse(return_code, error_message);
 
@@ -61,11 +62,11 @@ export class CosmosLedger extends CosmosLedgerInterface {
     const accountIndex = accounts.findIndex((account) => account.address === signerAddress);
 
     if (accountIndex === -1) {
-      throw new Error(`Address ${signerAddress} not found in wallet`);
+      throw new SwapKitError("wallet_ledger_address_not_found", { address: signerAddress });
     }
 
-    const { encodeSecp256k1Signature, serializeSignDoc } = await import("@cosmjs/amino");
-    const { Secp256k1Signature } = await import("@cosmjs/crypto");
+    const { encodeSecp256k1Signature, serializeSignDoc } = (await import("@cosmjs/amino")).default;
+    const { Secp256k1Signature } = (await import("@cosmjs/crypto")).default;
 
     const message = serializeSignDoc(signDoc);
     const signature = await this.ledgerApp.sign(this.derivationPath, message);

package/src/ledger/clients/evm.ts

@@ -3,6 +3,7 @@ import {
   ChainId,
   type DerivationPathArray,
   NetworkDerivationPath,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import { AbstractSigner, type Provider, type TransactionRequest } from "ethers";
@@ -51,14 +52,14 @@ class EVMLedgerInterface extends AbstractSigner {
 
   createTransportAndLedger = async () => {
     const transport = await getLedgerTransport();
-    const { default: EthereumApp } = await import("@ledgerhq/hw-app-eth");
+    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 Error("Could not get Address");
+    if (!response) throw new SwapKitError("wallet_ledger_failed_to_get_address");
     return response.address;
   };
 
@@ -78,7 +79,7 @@ class EVMLedgerInterface extends AbstractSigner {
 
     const sig = await this.ledgerApp?.signPersonalMessage(this.derivationPath, messageHex);
 
-    if (!sig) throw new Error("Signing failed");
+    if (!sig) throw new SwapKitError("wallet_ledger_signing_error");
 
     sig.r = `0x${sig.r}`;
     sig.s = `0x${sig.s}`;
@@ -86,7 +87,7 @@ class EVMLedgerInterface extends AbstractSigner {
   };
 
   sendTransaction = async (tx: TransactionRequest): Promise<any> => {
-    if (!this.provider) throw new Error("No provider set");
+    if (!this.provider) throw new SwapKitError("wallet_ledger_no_provider");
 
     const signedTxHex = await this.signTransaction(tx);
 
@@ -94,7 +95,7 @@ class EVMLedgerInterface extends AbstractSigner {
   };
 
   signTypedData(): Promise<string> {
-    throw new Error("Method not implemented.");
+    throw new SwapKitError("wallet_ledger_method_not_supported", { method: "signTypedData" });
   }
 
   signTransaction = async (tx: TransactionRequest) => {
@@ -141,7 +142,7 @@ class EVMLedgerInterface extends AbstractSigner {
       resolution,
     );
 
-    if (!signature) throw new Error("Could not sign transaction");
+    if (!signature) throw new SwapKitError("wallet_ledger_signing_error");
 
     const { r, s, v } = signature;
 

package/src/ledger/clients/near.ts

@@ -0,0 +1,86 @@
+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/helpers.ts

@@ -1,3 +1,4 @@
+import { SwapKitError } from "@swapkit/helpers";
 import {
   CLA,
   ERROR_CODE,
@@ -10,10 +11,10 @@ import {
 
 export function serializePathv1(path: number[]) {
   if (path == null || path.length < 3) {
-    throw new Error("Invalid path.");
+    throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Path too short" });
   }
   if (path.length > 10) {
-    throw new Error("Invalid path. Length should be <= 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);
@@ -61,7 +62,9 @@ export async function signSendChunkv1(
 
 function compressPublicKey(publicKey: Buffer) {
   if (publicKey.length !== 65) {
-    throw new Error("decompressed public key length should be 65 bytes");
+    throw new SwapKitError("wallet_ledger_invalid_params", {
+      reason: "decompressed public key length should be 65 bytes",
+    });
   }
   const y = publicKey.slice(33, 65);
 
@@ -90,7 +93,9 @@ export async function publicKeyv1(app: any, data: Buffer) {
 
 export function serializePathv2(path: number[]) {
   if (!path || path.length !== 5) {
-    throw new Error("Invalid path.");
+    throw new SwapKitError("wallet_ledger_invalid_params", {
+      reason: "Path must be exactly 5 elements",
+    });
   }
 
   const buf = Buffer.alloc(20);

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

@@ -1,5 +1,5 @@
 import { base64 } from "@scure/base";
-import { type DerivationPathArray, NetworkDerivationPath } from "@swapkit/helpers";
+import { type DerivationPathArray, NetworkDerivationPath, SwapKitError } from "@swapkit/helpers";
 
 import { CosmosLedgerInterface } from "../../interfaces/CosmosLedgerInterface";
 import type { GetAddressAndPubKeyResponse } from "../../types";
@@ -64,7 +64,7 @@ export class THORChainLedger extends CosmosLedgerInterface {
       rawTx,
     );
 
-    if (!this.pubKey) throw new Error("Public Key not found");
+    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
 
     this.validateResponse(return_code, error_message);
 
@@ -85,7 +85,7 @@ export class THORChainLedger extends CosmosLedgerInterface {
       message,
     );
 
-    if (!this.pubKey) throw new Error("Public Key not found");
+    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
 
     this.validateResponse(return_code, error_message);
 

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

@@ -1,4 +1,5 @@
 import type Transport from "@ledgerhq/hw-transport";
+import { SwapKitError } from "@swapkit/helpers";
 /** ******************************************************************************
  *  (c) 2019 ZondaX GmbH
  *  (c) 2016-2017 Ledger
@@ -42,7 +43,7 @@ export class THORChainApp {
 
   constructor(transport: any) {
     if (!transport) {
-      throw new Error("Transport has not been defined");
+      throw new SwapKitError("wallet_ledger_transport_not_defined");
     }
 
     this.transport = transport;
@@ -50,7 +51,7 @@ export class THORChainApp {
 
   static serializeHRP(hrp: string) {
     if (hrp == null || hrp.length < 3 || hrp.length > 83) {
-      throw new Error("Invalid HRP");
+      throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Invalid HRP" });
     }
     const buf = Buffer.alloc(1 + hrp.length);
     buf.writeUInt8(hrp.length, 0);

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

@@ -1,19 +1,26 @@
 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 Error("Invalid Signature: Too short");
+    throw new SwapKitError("wallet_ledger_invalid_signature", { reason: "Too short" });
   }
   if (signatureArray[0] !== 0x30) {
-    throw new Error("Invalid Ledger Signature TLV encoding: expected first byte 0x30");
+    throw new SwapKitError("wallet_ledger_invalid_signature", {
+      reason: "TLV encoding: expected first byte 0x30",
+    });
   }
   if (signatureArray[1] + 2 !== signatureArray.length) {
-    throw new Error("Invalid Signature: signature length does not match TLV");
+    throw new SwapKitError("wallet_ledger_invalid_signature", {
+      reason: "signature length does not match TLV",
+    });
   }
   if (signatureArray[2] !== 0x02) {
-    throw new Error("Invalid Ledger Signature TLV encoding: expected length type 0x02");
+    throw new SwapKitError("wallet_ledger_invalid_signature", {
+      reason: "TLV encoding: expected length type 0x02",
+    });
   }
 
   // r signature
@@ -24,7 +31,7 @@ export const getSignature = (signatureArray: any) => {
   if (rSignature.length === 33 && rSignature[0] === 0) {
     rSignature = rSignature.slice(1, 33);
   } else if (rSignature.length === 33) {
-    throw new Error('Invalid signature: "r" too long');
+    throw new SwapKitError("wallet_ledger_invalid_signature", { reason: "r too long" });
   }
 
   // add leading zero's to pad to 32 bytes
@@ -34,13 +41,17 @@ export const getSignature = (signatureArray: any) => {
 
   // s signature
   if (signatureArray[rLength + 4] !== 0x02) {
-    throw new Error("Invalid Ledger Signature TLV encoding: expected length type 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 Error("Invalid Ledger Signature: TLV byte lengths do not match message 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);
@@ -49,7 +60,7 @@ export const getSignature = (signatureArray: any) => {
   if (sSignature.length === 33 && sSignature[0] === 0) {
     sSignature = sSignature.slice(1, 33);
   } else if (sSignature.length === 33) {
-    throw new Error('Invalid signature: "s" too long');
+    throw new SwapKitError("wallet_ledger_invalid_signature", { reason: "s too long" });
   }
 
   // add leading zero's to pad to 32 bytes
@@ -58,7 +69,7 @@ export const getSignature = (signatureArray: any) => {
   }
 
   if (rSignature.length !== 32 || sSignature.length !== 32) {
-    throw new Error("Invalid signatures: must be 32 bytes each");
+    throw new SwapKitError("wallet_ledger_invalid_signature", { reason: "must be 32 bytes each" });
   }
 
   return base64.encode(Buffer.concat([rSignature, sSignature]));

package/src/ledger/clients/utxo.ts

@@ -7,7 +7,7 @@ import {
   getWalletFormatFor,
 } from "@swapkit/helpers";
 import type { UTXOType } from "@swapkit/toolboxes/utxo";
-import type { Psbt } from "bitcoinjs-lib";
+import { type Psbt, Transaction } from "bitcoinjs-lib";
 
 import { getLedgerTransport } from "../helpers/getLedgerTransport";
 
@@ -22,8 +22,6 @@ const signUTXOTransaction = async (
   { psbt, inputUtxos, btcApp, derivationPath }: Params,
   options?: Partial<CreateTransactionArg>,
 ) => {
-  const { Transaction } = await import("bitcoinjs-lib");
-
   const inputs = inputUtxos.map((item) => {
     const utxoTx = Transaction.fromHex(item.txHex || "");
     const splitTx = btcApp.splitTransaction(utxoTx.toHex(), utxoTx.hasWitnesses());
@@ -75,7 +73,7 @@ const BaseLedgerUTXO = ({
 
   async function createTransportWebUSB() {
     transport = await getLedgerTransport();
-    const { default: BitcoinApp } = await import("@ledgerhq/hw-app-btc");
+    const BitcoinApp = (await import("@ledgerhq/hw-app-btc")).default;
 
     btcApp = new BitcoinApp({ transport, currency: chain });
   }
@@ -91,7 +89,7 @@ const BaseLedgerUTXO = ({
     return {
       connect: async () => {
         await checkBtcAppAndCreateTransportWebUSB(false);
-        const { default: BitcoinApp } = await import("@ledgerhq/hw-app-btc");
+        const BitcoinApp = (await import("@ledgerhq/hw-app-btc")).default;
 
         btcApp = new BitcoinApp({ transport, currency: chain });
       },

package/src/ledger/clients/xrp.ts

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