@swapkit/wallets 4.0.0-beta.38 → 4.0.0-beta.40

package/package.json

@@ -12,6 +12,7 @@
     "@ledgerhq/hw-app-cosmos": "^6.32.0",
     "@ledgerhq/hw-app-eth": "^6.45.0",
     "@ledgerhq/hw-app-near": "^6.31.0",
+    "@ledgerhq/hw-app-trx": "^6.31.3",
     "@ledgerhq/hw-app-xrp": "^6.31.0",
     "@ledgerhq/hw-transport": "^6.31.0",
     "@ledgerhq/hw-transport-webusb": "^6.29.0",
@@ -23,8 +24,8 @@
     "@scure/base": "^1.2.0",
     "@scure/bip39": "^1.6.0",
     "@solana/web3.js": "^1.98.0",
-    "@swapkit/helpers": "^4.0.0-beta.24",
-    "@swapkit/toolboxes": "^4.0.0-beta.35",
+    "@swapkit/helpers": "^4.0.0-beta.25",
+    "@swapkit/toolboxes": "^4.0.0-beta.37",
     "@trezor/connect-web": "^9.6.0",
     "@walletconnect/modal": "^2.7.0",
     "@walletconnect/sign-client": "^2.21.0",
@@ -50,6 +51,7 @@
     "@ledgerhq/hw-app-cosmos": "6.32.2",
     "@ledgerhq/hw-app-eth": "6.45.6",
     "@ledgerhq/hw-app-near": "6.31.2",
+    "@ledgerhq/hw-app-trx": "6.31.3",
     "@ledgerhq/hw-app-xrp": "6.31.2",
     "@ledgerhq/hw-transport": "6.31.6",
     "@ledgerhq/hw-transport-webusb": "6.29.6",
@@ -61,8 +63,8 @@
     "@scure/base": "1.2.6",
     "@scure/bip39": "1.6.0",
     "@solana/web3.js": "1.98.2",
-    "@swapkit/helpers": "4.0.0-beta.24",
-    "@swapkit/toolboxes": "4.0.0-beta.35",
+    "@swapkit/helpers": "4.0.0-beta.25",
+    "@swapkit/toolboxes": "4.0.0-beta.37",
     "@trezor/connect-web": "9.6.0",
     "@walletconnect/logger": "2.1.2",
     "@walletconnect/modal": "2.7.0",
@@ -74,7 +76,8 @@
     "near-api-js": "6.1.0",
     "ripple-binary-codec": "2.4.1",
     "sats-connect": "3.5.0",
-    "ts-pattern": "5.7.1"
+    "ts-pattern": "5.7.1",
+    "xumm": "1.8.0"
   },
   "exports": {
     ".": {
@@ -176,6 +179,11 @@
       "default": "./dist/src/walletconnect/index.js",
       "require": "./dist/src/walletconnect/index.cjs",
       "types": "./src/walletconnect/index.ts"
+    },
+    "./xaman": {
+      "default": "./dist/src/xaman/index.js",
+      "require": "./dist/src/xaman/index.cjs",
+      "types": "./src/xaman/index.ts"
     }
   },
   "files": [
@@ -197,5 +205,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "4.0.0-beta.38"
+  "version": "4.0.0-beta.40"
 }

package/src/bitget/helpers.ts

@@ -6,33 +6,42 @@ import {
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
+import type { TronTransaction } from "@swapkit/toolboxes/tron";
 import { Psbt } from "bitcoinjs-lib";
 import type { Eip1193Provider } from "ethers";
 
 export async function getWalletMethods(chain: Chain) {
+  const { match, P } = await import("ts-pattern");
   const bitget = window.bitkeep;
 
-  switch (chain) {
-    case Chain.Ethereum:
-    case Chain.Base:
-    case Chain.Avalanche:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.BinanceSmartChain: {
-      if (!(bitget && "ethereum" in bitget)) {
-        throw new SwapKitError("wallet_bitkeep_not_found");
-      }
-
-      const wallet = bitget.ethereum;
-
-      const [address]: [string] = await wallet.send("eth_requestAccounts", []);
-      const evmWallet = await getWeb3WalletMethods({ chain, walletProvider: wallet });
-
-      return { ...evmWallet, address };
-    }
-
-    case Chain.Bitcoin: {
+  return match(chain)
+    .with(
+      P.union(
+        Chain.Ethereum,
+        Chain.Base,
+        Chain.Avalanche,
+        Chain.Arbitrum,
+        Chain.Optimism,
+        Chain.Polygon,
+        Chain.BinanceSmartChain,
+      ),
+      async () => {
+        if (!(bitget && "ethereum" in bitget)) {
+          throw new SwapKitError("wallet_bitkeep_not_found");
+        }
+
+        const wallet = bitget.ethereum;
+
+        const [address]: [string] = await wallet.send("eth_requestAccounts", []);
+        const evmWallet = await getWeb3WalletMethods({
+          chain: chain as EVMChain,
+          walletProvider: wallet,
+        });
+
+        return { ...evmWallet, address };
+      },
+    )
+    .with(Chain.Bitcoin, async () => {
       if (!(bitget && "unisat" in bitget)) {
         throw new SwapKitError("wallet_bitkeep_not_found");
       }
@@ -55,9 +64,8 @@ export async function getWalletMethods(chain: Chain) {
       const toolbox = await getUtxoToolbox(Chain.Bitcoin, { signer });
 
       return { ...toolbox, address };
-    }
-
-    case Chain.Cosmos: {
+    })
+    .with(Chain.Cosmos, async () => {
       if (!(bitget && "keplr" in bitget)) {
         throw new SwapKitError("wallet_bitkeep_not_found");
       }
@@ -83,9 +91,8 @@ export async function getWalletMethods(chain: Chain) {
       });
 
       return { ...toolbox, address };
-    }
-
-    case Chain.Solana: {
+    })
+    .with(Chain.Solana, async () => {
       if (!(bitget && "solana" in bitget)) {
         throw new SwapKitError("wallet_bitkeep_not_found");
       }
@@ -98,11 +105,39 @@ export async function getWalletMethods(chain: Chain) {
       const address: string = providerConnection.publicKey.toString();
 
       return { ...toolbox, address };
-    }
+    })
+    .with(Chain.Tron, async () => {
+      if (!(bitget && "tronLink" in bitget && "tronWeb" in bitget)) {
+        throw new SwapKitError("wallet_bitkeep_not_found");
+      }
+
+      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const { tronLink, tronWeb } = bitget;
+
+      // Request account access
+      const account = await tronLink.request({ method: "tron_requestAccounts" });
+      if (!account?.base58) {
+        throw new SwapKitError("wallet_bitkeep_no_accounts", { chain: Chain.Tron });
+      }
+
+      const address = account.base58;
+
+      // Create signer compatible with TronSigner interface
+      const signer = {
+        getAddress: () => Promise.resolve(address),
+        signTransaction: async (transaction: TronTransaction) => {
+          const signedTx = await tronWeb.trx.sign(transaction);
+          return signedTx;
+        },
+      };
 
-    default:
+      const toolbox = await createTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    })
+    .otherwise(() => {
       throw new SwapKitError("wallet_chain_not_supported");
-  }
+    });
 }
 
 export const getWeb3WalletMethods = async ({

package/src/bitget/index.ts

@@ -12,7 +12,7 @@ import { getWalletMethods } from "./helpers";
 export const bitgetWallet = createWallet({
   name: "connectBitget",
   walletType: WalletOption.BITGET,
-  supportedChains: [...EVMChains, Chain.Cosmos, Chain.Bitcoin, Chain.Solana],
+  supportedChains: [...EVMChains, Chain.Cosmos, Chain.Bitcoin, Chain.Solana, Chain.Tron],
   connect: ({ addChain, walletType, supportedChains }) =>
     async function connectBitget(chains: Chain[]) {
       const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });

package/src/keepkey/chains/ripple.ts

@@ -0,0 +1,118 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  type GenericTransferParams,
+  derivationPathToString,
+} from "@swapkit/helpers";
+import { bip32ToAddressNList } from "../coins";
+
+import { getRippleToolbox } from "@swapkit/toolboxes/ripple";
+
+export const rippleWalletMethods = async ({
+  sdk,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  derivationPath?: DerivationPathArray;
+}) => {
+  // Derivation path handling (default to standard XRP 44'/144'/0'/0/0)
+  const derivationPathString = derivationPath
+    ? derivationPathToString(derivationPath)
+    : `${DerivationPath[Chain.Ripple]}/0`;
+
+  // Fetch address from KeepKey
+  // @ts-ignore - keepkey-sdk typings may not yet include xrpGetAddress
+  const { address } = await (sdk as any).address.xrpGetAddress({
+    address_n: bip32ToAddressNList(derivationPathString),
+  });
+
+  // Inject minimal signer so toolbox's address helpers work
+  const signer = {
+    getAddress: () => Promise.resolve(address),
+    signTransaction: () => {
+      throw new Error("signTransaction not supported via toolbox");
+    },
+  };
+
+  const toolbox = await getRippleToolbox({ signer });
+
+  const transfer = async ({ recipient, assetValue, memo }: GenericTransferParams) => {
+    // Build XRPL Payment tx using toolbox helper
+    const tx = await toolbox.createTransaction({
+      assetValue,
+      recipient,
+      memo,
+      sender: address,
+    });
+
+    // Convert toolbox Payment tx into KeepKey StdTx wrapper (KeepKey-specific format)
+    const stdTx = {
+      type: "auth/StdTx",
+      value: {
+        fee: {
+          amount: [
+            {
+              amount: "1000",
+              denom: "drop",
+            },
+          ],
+          gas: "28000",
+        },
+        memo: memo && memo.length > 0 ? memo : "",
+        msg: [
+          {
+            type: "ripple-sdk/MsgSend",
+            value: {
+              amount: [
+                {
+                  amount: tx.Amount,
+                  denom: "drop",
+                },
+              ],
+              from_address: address,
+              to_address: recipient,
+            },
+          },
+        ],
+        signatures: null,
+      },
+    };
+
+    const unsignedTx = {
+      addressNList: bip32ToAddressNList(derivationPathString),
+      tx: stdTx,
+      flags: tx.Flags === 0 ? undefined : tx.Flags,
+      lastLedgerSequence: tx.LastLedgerSequence?.toString(),
+      sequence: (tx.Sequence ?? 0).toString(),
+      payment: {
+        amount: tx.Amount,
+        destination: tx.Destination,
+        destinationTag: (tx.DestinationTag ?? "0").toString(),
+      },
+    } as any;
+
+    // Sign with KeepKey
+    // @ts-ignore - typings missing
+    const responseSign = JSON.parse(await (sdk as any).xrp.xrpSignTransaction(unsignedTx));
+
+    // keepkey-sdk may return either { tx_blob } or StdTx with Base64 serializedTx
+    const txBlob: string | undefined =
+      (responseSign as any).tx_blob ?? (responseSign as any).value?.signatures?.[0]?.serializedTx;
+    if (!txBlob) throw new Error("KeepKey XRP sign failed");
+
+    const buffer = Buffer.from(txBlob, "base64");
+    const txBlobHex = buffer.toString("hex");
+
+    // Broadcast signed tx via toolbox
+    return toolbox.broadcastTransaction(txBlobHex);
+  };
+
+  return {
+    ...toolbox,
+    address,
+    getAddress: () => address,
+    transfer,
+  };
+};

package/src/keepkey/coins.ts

@@ -12,6 +12,7 @@ export enum ChainToKeepKeyName {
   DOGE = "Dogecoin",
   LTC = "Litecoin",
   DASH = "Dash",
+  XRP = "Ripple",
 }
 
 export function addressNListToBIP32(address: number[]) {

package/src/keepkey/index.ts

@@ -33,6 +33,7 @@ export const keepkeyWallet = createWallet({
     Chain.Dash,
     Chain.Ethereum,
     Chain.Litecoin,
+    Chain.Ripple,
     Chain.Optimism,
     Chain.Polygon,
     Chain.THORChain,
@@ -116,6 +117,10 @@ 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 SwapKitError("wallet_keepkey_chain_not_supported", { chain });
   }

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,
   ],

package/src/ledger/clients/tron.ts

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

@@ -1,6 +1,7 @@
 import { Chain, SwapKitError, WalletOption } from "@swapkit/helpers";
 
 import type { getNearLedgerClient } from "../clients/near";
+import type { TronLedger } from "../clients/tron";
 import type { XRPLedger } from "../clients/xrp";
 import type { LEDGER_SUPPORTED_CHAINS } from "../index";
 import type { CosmosLedgerClients, EVMLedgerClients, UTXOLedgerClients } from "../types";
@@ -54,6 +55,10 @@ export const getLedgerAddress = async <
       return (ledgerClient as Awaited<ReturnType<typeof XRPLedger>>).address;
     }
 
+    case Chain.Tron: {
+      return (ledgerClient as Awaited<ReturnType<typeof TronLedger>>).getAddress();
+    }
+
     default:
       throw new SwapKitError("wallet_chain_not_supported", { wallet: WalletOption.LEDGER, chain });
   }

package/src/ledger/helpers/getLedgerClient.ts

@@ -18,6 +18,7 @@ import {
 } from "../clients/evm";
 import { getNearLedgerClient } from "../clients/near";
 import { THORChainLedger } from "../clients/thorchain";
+import { TronLedger } from "../clients/tron";
 import {
   BitcoinCashLedger,
   BitcoinLedger,
@@ -45,6 +46,7 @@ type LedgerSignerMap = {
   [Chain.Polygon]: ReturnType<typeof PolygonLedger>;
   [Chain.Ripple]: ReturnType<typeof XRPLedger>;
   [Chain.THORChain]: THORChainLedger;
+  [Chain.Tron]: ReturnType<typeof TronLedger>;
 };
 
 type LedgerSupportedChain = keyof LedgerSignerMap;
@@ -78,6 +80,7 @@ export const getLedgerClient = async <T extends LedgerSupportedChain>({
       Promise.resolve(LitecoinLedger(derivationPath) as LedgerSignerMap[T]),
     )
     .with(Chain.Ripple, () => Promise.resolve(XRPLedger(derivationPath) as LedgerSignerMap[T]))
+    .with(Chain.Tron, () => Promise.resolve(TronLedger(derivationPath) as LedgerSignerMap[T]))
     .with(Chain.Near, async () => {
       const transport = await getLedgerTransport();
       return getNearLedgerClient(transport, derivationPath) as unknown as LedgerSignerMap[T];

package/src/ledger/index.ts

@@ -36,6 +36,7 @@ export const ledgerWallet = createWallet({
     Chain.Polygon,
     Chain.Ripple,
     Chain.THORChain,
+    Chain.Tron,
   ],
   walletType: WalletOption.LEDGER,
   connect: ({ addChain, supportedChains, walletType }) =>
@@ -288,6 +289,15 @@ async function getWalletMethods({
       return { ...toolbox, address };
     }
 
+    case Chain.Tron: {
+      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+      const toolbox = await createTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
     default:
       throw new SwapKitError("wallet_ledger_chain_not_supported", { chain });
   }

package/src/ledger/types.ts

@@ -9,6 +9,7 @@ import type {
   PolygonLedger,
 } from "./clients/evm";
 import type { THORChainLedger } from "./clients/thorchain";
+import type { TronLedger } from "./clients/tron";
 import type {
   BitcoinCashLedger,
   BitcoinLedger,
@@ -30,6 +31,7 @@ export type EVMLedgerClients =
   | ReturnType<typeof EthereumLedger>
   | ReturnType<typeof OptimismLedger>
   | ReturnType<typeof PolygonLedger>;
+export type TronLedgerClient = ReturnType<typeof TronLedger>;
 
 export type GetAddressAndPubKeyResponse = {
   bech32_address: string;