@swapkit/wallets 3.0.0-beta.17 → 3.0.0-beta.19

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 };
+};

package/src/ledger/helpers/getLedgerAddress.ts

@@ -1,15 +1,19 @@
 import { Chain, SwapKitError, WalletOption } from "@swapkit/helpers";
 
+import type { XRPLedger } from "../clients/xrp";
 import type { LEDGER_SUPPORTED_CHAINS } from "../index";
 import type { CosmosLedgerClients, EVMLedgerClients, UTXOLedgerClients } from "../types";
 import type { getLedgerClient } from "./getLedgerClient";
 
-export const getLedgerAddress = async ({
+export const getLedgerAddress = async <
+  T extends (typeof LEDGER_SUPPORTED_CHAINS)[number],
+  L extends Awaited<ReturnType<typeof getLedgerClient<T>>>,
+>({
   chain,
   ledgerClient,
 }: {
-  chain: (typeof LEDGER_SUPPORTED_CHAINS)[number];
-  ledgerClient: Awaited<ReturnType<typeof getLedgerClient>>;
+  chain: T;
+  ledgerClient: L;
 }) => {
   if (!ledgerClient) return "";
 
@@ -40,6 +44,11 @@ export const getLedgerAddress = async ({
 
       return chain === Chain.BitcoinCash ? address.replace("bitcoincash:", "") : address;
     }
+
+    case Chain.Ripple: {
+      return (ledgerClient as Awaited<ReturnType<typeof XRPLedger>>).address;
+    }
+
     default:
       throw new SwapKitError("wallet_chain_not_supported", { wallet: WalletOption.LEDGER, chain });
   }

package/src/ledger/helpers/getLedgerClient.ts

@@ -18,6 +18,7 @@ import {
   DogecoinLedger,
   LitecoinLedger,
 } from "../clients/utxo";
+import { XRPLedger } from "../clients/xrp";
 
 type LedgerSignerMap = {
   [Chain.Arbitrum]: ReturnType<typeof ArbitrumLedger>;
@@ -33,6 +34,7 @@ type LedgerSignerMap = {
   [Chain.Litecoin]: ReturnType<typeof LitecoinLedger>;
   [Chain.Optimism]: ReturnType<typeof OptimismLedger>;
   [Chain.Polygon]: ReturnType<typeof PolygonLedger>;
+  [Chain.Ripple]: ReturnType<typeof XRPLedger>;
   [Chain.THORChain]: THORChainLedger;
 };
 
@@ -60,6 +62,8 @@ export const getLedgerClient = async <T extends LedgerSupportedChain>({
       return DogecoinLedger(derivationPath) as LedgerSignerMap[T];
     case Chain.Litecoin:
       return LitecoinLedger(derivationPath) as LedgerSignerMap[T];
+    case Chain.Ripple:
+      return XRPLedger(derivationPath) as LedgerSignerMap[T];
 
     case Chain.Arbitrum:
     case Chain.Avalanche:

package/src/ledger/index.ts

@@ -32,6 +32,7 @@ export const ledgerWallet = createWallet({
     Chain.Litecoin,
     Chain.Optimism,
     Chain.Polygon,
+    Chain.Ripple,
     Chain.THORChain,
   ],
   walletType: WalletOption.LEDGER,
@@ -267,6 +268,15 @@ async function getWalletMethods({
       return { ...toolbox, address, deposit, transfer, signMessage };
     }
 
+    case Chain.Ripple: {
+      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = signer.address;
+      const toolbox = await getRippleToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
     default:
       throw new Error("Unsupported chain");
   }

package/src/trezor/index.ts

@@ -233,7 +233,17 @@ export const trezorWallet = createWallet({
       const { success } = await TrezorConnect.getDeviceState();
 
       if (!success) {
-        const manifest = SKConfig.get("integrations").trezor || { appUrl: "", email: "" };
+        const trezorConfig = SKConfig.get("integrations").trezor;
+        const manifest = trezorConfig
+          ? {
+              ...trezorConfig,
+              appName: (trezorConfig as any).appName || "SwapKit",
+            }
+          : {
+              appUrl: "",
+              email: "",
+              appName: "SwapKit",
+            };
         TrezorConnect.init({ lazyLoad: true, manifest });
       }
 

package/src/types.ts

@@ -12,6 +12,7 @@ import type { BrowserProvider, Eip1193Provider } from "ethers";
 import type { SubstrateInjectedExtension } from "@swapkit/toolboxes/substrate";
 import type { bitgetWallet } from "./bitget";
 import type { coinbaseWallet } from "./coinbase";
+import type { cosmostationWallet } from "./cosmostation";
 import type { ctrlWallet } from "./ctrl";
 import type { evmWallet } from "./evm-extensions";
 import type { exodusWallet } from "./exodus";
@@ -34,6 +35,7 @@ export type SKWallets = {
   [WalletOption.BRAVE]: typeof evmWallet;
   [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet;
   [WalletOption.COINBASE_WEB]: typeof evmWallet;
+  [WalletOption.COSMOSTATION]: typeof cosmostationWallet;
   [WalletOption.CTRL]: typeof ctrlWallet;
   [WalletOption.EIP6963]: typeof evmWallet;
   [WalletOption.EXODUS]: typeof exodusWallet;
@@ -64,6 +66,7 @@ export type SKWalletsSupportedChains = {
   [WalletOption.BRAVE]: typeof evmWallet.connectEVMWallet.supportedChains;
   [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet.connectCoinbaseWallet.supportedChains;
   [WalletOption.COINBASE_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.COSMOSTATION]: typeof cosmostationWallet.connectCosmostation.supportedChains;
   [WalletOption.CTRL]: typeof ctrlWallet.connectCtrl.supportedChains;
   [WalletOption.EIP6963]: typeof evmWallet.connectEVMWallet.supportedChains;
   [WalletOption.EXODUS]: typeof exodusWallet.connectExodusWallet.supportedChains;

package/src/utils.ts

@@ -25,6 +25,10 @@ export async function loadWallet<W extends WalletOption>(walletOption: W): Promi
       async () => (await import("./walletconnect")).walletconnectWallet,
     )
     .with(WalletOption.KEPLR, WalletOption.LEAP, async () => (await import("./keplr")).keplrWallet)
+    .with(
+      WalletOption.COSMOSTATION,
+      async () => (await import("./cosmostation")).cosmostationWallet,
+    )
     .with(
       WalletOption.BRAVE,
       WalletOption.COINBASE_WEB,

package/dist/chunk-wja505db.js

@@ -1,4 +0,0 @@
-import{c as a,d as e}from"./chunk-p1kdg37m.js";import{WalletOption as t}from"@swapkit/helpers";function r(i){let l=Object.keys(i)?.[0]||"";return i?.[l]?.supportedChains||[]}async function p(i){let{match:l}=await import("ts-pattern");return await l(i).with(t.COINBASE_MOBILE,async()=>(await import("./src/coinbase/index.js")).coinbaseWallet).with(t.BITGET,async()=>(await import("./src/bitget/index.js")).bitgetWallet).with(t.CTRL,async()=>(await import("./src/ctrl/index.js")).ctrlWallet).with(t.OKX,async()=>(await import("./src/okx/index.js")).okxWallet).with(t.ONEKEY,async()=>(await import("./src/onekey/index.js")).onekeyWallet).with(t.EXODUS,async()=>(await import("./src/exodus/index.js")).exodusWallet).with(t.KEEPKEY,async()=>(await import("./src/keepkey/index.js")).keepkeyWallet).with(t.KEEPKEY_BEX,async()=>(await import("./src/keepkey-bex/index.js")).keepkeyBexWallet).with(t.WALLETCONNECT,async()=>(await import("./src/walletconnect/index.js")).walletconnectWallet).with(t.KEPLR,t.LEAP,async()=>(await import("./src/keplr/index.js")).keplrWallet).with(t.BRAVE,t.COINBASE_WEB,t.EIP6963,t.METAMASK,t.OKX_MOBILE,t.TRUSTWALLET_WEB,async()=>(await import("./src/evm-extensions/index.js")).evmWallet).with(t.KEYSTORE,async()=>(await import("./src/keystore/index.js")).keystoreWallet).with(t.TREZOR,async()=>(await import("./src/trezor/index.js")).trezorWallet).with(t.LEDGER,t.LEDGER_LIVE,async()=>(await import("./src/ledger/index.js")).ledgerWallet).with(t.PHANTOM,async()=>(await import("./src/phantom/index.js")).phantomWallet).with(t.POLKADOT_JS,async()=>(await import("./src/polkadotjs/index.js")).polkadotWallet).with(t.RADIX_WALLET,async()=>(await import("./src/radix/index.js")).radixWallet).with(t.TALISMAN,async()=>(await import("./src/talisman/index.js")).talismanWallet).exhaustive()}
-export{r as a,p as b};
-
-//# debugId=40B36BBD4009778C64756E2164756E21