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

package/src/okx/helpers.ts

@@ -2,17 +2,19 @@ import {
   Chain,
   ChainId,
   type EVMChain,
+  type GenericTransferParams,
   SKConfig,
   SwapKitError,
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
+import type { TronSigner, TronTransaction } from "@swapkit/toolboxes/tron";
 import { Psbt } from "bitcoinjs-lib";
 import type { Eip1193Provider } from "ethers";
 
 const cosmosTransfer =
-  () =>
-  async ({ from, recipient, amount, asset, memo }: any) => {
+  (sender: string) =>
+  async ({ recipient, assetValue, memo }: GenericTransferParams) => {
     if (!(window.okxwallet && "keplr" in window.okxwallet)) {
       throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Cosmos });
     }
@@ -25,12 +27,12 @@ const cosmosTransfer =
 
     const coins = [
       {
-        denom: asset?.symbol === "MUON" ? "umuon" : "uatom",
-        amount: amount.amount().toString(),
+        denom: assetValue?.symbol === "MUON" ? "umuon" : "uatom",
+        amount: assetValue.getBaseValue("string"),
       },
     ];
 
-    const { transactionHash } = await cosmJS.sendTokens(from, recipient, coins, 1.6, memo);
+    const { transactionHash } = await cosmJS.sendTokens(sender, recipient, coins, 1.6, memo);
     return transactionHash;
   };
 
@@ -58,28 +60,34 @@ async function getWeb3WalletMethods({
 }
 
 export async function getWalletMethods(chain: Chain) {
-  switch (chain) {
-    case Chain.Ethereum:
-    case Chain.Base:
-    case Chain.Avalanche:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.BinanceSmartChain: {
-      if (!(window.okxwallet && "send" in window.okxwallet)) {
-        throw new SwapKitError("wallet_okx_not_found", { chain });
-      }
-
-      const evmWallet = await getWeb3WalletMethods({
-        chain,
-        walletProvider: window.okxwallet,
-      });
-      const address: string = (await window.okxwallet.send("eth_requestAccounts", [])).result[0];
-
-      return { ...evmWallet, address };
-    }
-
-    case Chain.Bitcoin: {
+  const { match, P } = await import("ts-pattern");
+
+  return match(chain)
+    .with(
+      P.union(
+        Chain.Ethereum,
+        Chain.Base,
+        Chain.Avalanche,
+        Chain.Arbitrum,
+        Chain.Optimism,
+        Chain.Polygon,
+        Chain.BinanceSmartChain,
+      ),
+      async () => {
+        if (!(window.okxwallet && "send" in window.okxwallet)) {
+          throw new SwapKitError("wallet_okx_not_found", { chain });
+        }
+
+        const evmWallet = await getWeb3WalletMethods({
+          chain: chain as EVMChain,
+          walletProvider: window.okxwallet,
+        });
+        const address: string = (await window.okxwallet.send("eth_requestAccounts", [])).result[0];
+
+        return { ...evmWallet, address };
+      },
+    )
+    .with(Chain.Bitcoin, async () => {
       if (!(window.okxwallet && "bitcoin" in window.okxwallet)) {
         throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Bitcoin });
       }
@@ -101,12 +109,11 @@ export async function getWalletMethods(chain: Chain) {
         getAddress: async () => Promise.resolve(address),
       };
 
-      const toolbox = await getUtxoToolbox(chain, { signer });
+      const toolbox = await getUtxoToolbox(Chain.Bitcoin, { signer });
 
       return { ...toolbox, address };
-    }
-
-    case Chain.Cosmos: {
+    })
+    .with(Chain.Cosmos, async () => {
       if (!(window.okxwallet && "keplr" in window.okxwallet)) {
         throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Cosmos });
       }
@@ -120,10 +127,9 @@ export async function getWalletMethods(chain: Chain) {
       const [{ address }] = accounts;
       const toolbox = getCosmosToolbox(Chain.Cosmos);
 
-      return { ...toolbox, address, transfer: cosmosTransfer() };
-    }
-
-    case Chain.Near: {
+      return { ...toolbox, address, transfer: cosmosTransfer(address) };
+    })
+    .with(Chain.Near, async () => {
       if (!(window.okxwallet && "near" in window.okxwallet)) {
         throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Near });
       }
@@ -137,9 +143,36 @@ export async function getWalletMethods(chain: Chain) {
       const toolbox = await getNearToolbox({ signer });
 
       return { ...toolbox, address: accountId };
-    }
+    })
+    .with(Chain.Tron, async () => {
+      if (!(window.okxwallet && "tronLink" in window.okxwallet)) {
+        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Tron });
+      }
 
-    default:
+      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
+
+      const tronLink = window.okxwallet.tronLink;
+
+      // Request account access
+      const accounts = await tronLink.request({ method: "tron_requestAccounts" });
+      if (!accounts || accounts.length === 0) {
+        throw new SwapKitError("wallet_okx_no_accounts", { chain: Chain.Tron });
+      }
+
+      const address = tronLink.tronWeb.defaultAddress.base58;
+
+      const signer: TronSigner = {
+        getAddress: async () => address,
+        signTransaction: async (transaction: TronTransaction) => {
+          return await tronLink.tronWeb.trx.sign(transaction);
+        },
+      };
+
+      const toolbox = await createTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    })
+    .otherwise(() => {
       throw new SwapKitError("wallet_okx_chain_not_supported", { chain });
-  }
+    });
 }

package/src/okx/index.ts

@@ -17,6 +17,7 @@ export const okxWallet = createWallet({
     Chain.Near,
     Chain.Optimism,
     Chain.Polygon,
+    Chain.Tron,
   ],
   connect: ({ addChain, supportedChains, walletType }) =>
     async function connectOkx(chains: Chain[]) {

package/src/onekey/index.ts

@@ -56,8 +56,8 @@ async function getWalletMethodsForExtension(chain: Chain) {
 
       await getAddress(getAddressOptions);
 
-      async function signTransaction(psbt: any) {
-        let signedPsbt: any;
+      async function signTransaction(psbt: Psbt) {
+        let signedPsbt: Psbt | undefined;
         const signPsbtOptions: SignTransactionOptions = {
           getProvider,
           payload: {

package/src/trezor/index.ts

@@ -112,16 +112,7 @@ async function getTrezorWallet<T extends Chain>({
             amount: value,
             script_type: scriptType.input,
           })),
-
-          // Lint is not happy with the type of txOutputs
-          outputs: psbt.txOutputs.map((output: any) => {
-            const outputAddress =
-              chain === Chain.BitcoinCash && output.address
-                ? toolbox.stripPrefix(toCashAddress(output.address))
-                : output.address;
-
-            const isChangeAddress = outputAddress === address;
-
+          outputs: psbt.txOutputs.map((output) => {
             // OP_RETURN
             if (!output.address) {
               return {
@@ -131,6 +122,13 @@ async function getTrezorWallet<T extends Chain>({
               };
             }
 
+            const outputAddress =
+              chain === Chain.BitcoinCash
+                ? toolbox.stripPrefix(toCashAddress(output.address))
+                : output.address;
+
+            const isChangeAddress = outputAddress === address;
+
             return isChangeAddress
               ? { amount: output.value, address_n, script_type: scriptType.output }
               : { amount: output.value, address: outputAddress, script_type: "PAYTOADDRESS" };

package/src/types.ts

@@ -30,6 +30,7 @@ import type { radixWallet } from "./radix";
 import type { talismanWallet } from "./talisman";
 import type { trezorWallet } from "./trezor";
 import type { walletconnectWallet } from "./walletconnect";
+import type { xamanWallet } from "./xaman";
 
 export type SKWallets = {
   [WalletOption.BITGET]: typeof bitgetWallet;
@@ -58,6 +59,7 @@ export type SKWallets = {
   [WalletOption.TREZOR]: typeof trezorWallet;
   [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet;
   [WalletOption.WALLETCONNECT]: typeof walletconnectWallet;
+  [WalletOption.XAMAN]: typeof xamanWallet;
 };
 
 export type SKConnectWallets = SKWallets[keyof SKWallets];
@@ -89,6 +91,7 @@ export type SKWalletsSupportedChains = {
   [WalletOption.TREZOR]: typeof trezorWallet.connectTrezor.supportedChains;
   [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
   [WalletOption.WALLETCONNECT]: typeof walletconnectWallet.connectWalletconnect.supportedChains;
+  [WalletOption.XAMAN]: typeof xamanWallet.connectXaman.supportedChains;
 };
 
 type UnisatToSignInputs = {
@@ -161,6 +164,22 @@ declare global {
       };
       solana: SolanaProvider;
       ethereum: EthereumWindowProvider;
+      tronLink: {
+        request: (args: { method: string; params?: any }) => Promise<any>;
+        ready: boolean;
+      };
+      tronWeb: {
+        defaultAddress: {
+          base58: string;
+          hex: string;
+        };
+        trx: {
+          sign: (transaction: any) => Promise<any>;
+          sendRawTransaction: (signedTransaction: any) => Promise<any>;
+          getAccount: (address: string) => Promise<any>;
+          getBalance: (address: string) => Promise<number>;
+        };
+      };
     };
 
     okxwallet?:
@@ -207,6 +226,22 @@ declare global {
               transactions: any[];
             }) => Promise<any>;
           };
+          tronLink: {
+            request: (args: { method: string; params?: any }) => Promise<any>;
+            ready: boolean;
+            tronWeb: {
+              defaultAddress: {
+                base58: string;
+                hex: string;
+              };
+              trx: {
+                sign: (transaction: any) => Promise<any>;
+                sendRawTransaction: (signedTransaction: any) => Promise<any>;
+                getAccount: (address: string) => Promise<any>;
+                getBalance: (address: string) => Promise<number>;
+              };
+            };
+          };
         }
       | EthereumWindowProvider;
   }

package/src/utils.ts

@@ -52,6 +52,7 @@ export async function loadWallet<W extends WalletOption>(walletOption: W): Promi
     .with(WalletOption.POLKADOT_JS, async () => (await import("./polkadotjs")).polkadotWallet)
     .with(WalletOption.RADIX_WALLET, async () => (await import("./radix")).radixWallet)
     .with(WalletOption.TALISMAN, async () => (await import("./talisman")).talismanWallet)
+    .with(WalletOption.XAMAN, async () => (await import("./xaman")).xamanWallet)
     .exhaustive();
 
   return wallet as SKWallets[W];

package/src/walletconnect/constants.ts

@@ -15,6 +15,7 @@ export const POLYGON_MAINNET_ID = "eip155:137";
 export const BASE_MAINNET_ID = "eip155:8453";
 export const NEAR_MAINNET_ID = "near:mainnet";
 export const NEAR_TESTNET_ID = "near:testnet";
+export const TRON_MAINNET_ID = "tron:0x2b6653dc";
 
 export const DEFAULT_LOGGER = "debug";
 
@@ -85,3 +86,15 @@ export enum DEFAULT_NEAR_METHODS {
 }
 
 export enum DEFAULT_NEAR_EVENTS {}
+
+/**
+ * TRON
+ */
+export enum DEFAULT_TRON_METHODS {
+  TRON_SIGN_MESSAGE = "tron_signMessage",
+  TRON_SIGN_TRANSACTION = "tron_signTransaction",
+  TRON_SEND_TRANSACTION = "tron_sendTransaction",
+  TRON_GET_ACCOUNTS = "tron_getAccounts",
+}
+
+export enum DEFAULT_TRON_EVENTS {}

package/src/walletconnect/helpers.ts

@@ -14,10 +14,18 @@ import {
   OPTIMISM_MAINNET_ID,
   POLYGON_MAINNET_ID,
   THORCHAIN_MAINNET_ID,
+  TRON_MAINNET_ID,
 } from "./constants";
 
 export const getAddressByChain = (
-  chain: EVMChain | Chain.THORChain | Chain.Maya | Chain.Kujira | Chain.Cosmos | Chain.Near,
+  chain:
+    | EVMChain
+    | Chain.THORChain
+    | Chain.Maya
+    | Chain.Kujira
+    | Chain.Cosmos
+    | Chain.Near
+    | Chain.Tron,
   accounts: string[],
 ) => {
   const account = accounts.find((account) => account.startsWith(chainToChainId(chain))) || "";
@@ -55,6 +63,8 @@ export const chainToChainId = (chain: Chain) => {
       const { isStagenet } = SKConfig.get("envs");
       return isStagenet ? NEAR_TESTNET_ID : NEAR_MAINNET_ID;
     }
+    case Chain.Tron:
+      return TRON_MAINNET_ID;
     default:
       return "";
   }

package/src/walletconnect/index.ts

@@ -11,6 +11,7 @@ import {
 } from "@swapkit/helpers";
 import type { ThorchainDepositParams, createThorchainToolbox } from "@swapkit/toolboxes/cosmos";
 import type { NearSigner } from "@swapkit/toolboxes/near";
+import type { TronSignedTransaction, TronSigner, TronTransaction } from "@swapkit/toolboxes/tron";
 import type { WalletConnectModal } from "@walletconnect/modal";
 import type { SessionTypes, SignClientTypes } from "@walletconnect/types";
 import type { Transaction } from "near-api-js/lib/transaction";
@@ -47,6 +48,7 @@ export const walletconnectWallet = createWallet({
     Chain.Optimism,
     Chain.Polygon,
     Chain.THORChain,
+    Chain.Tron,
   ],
   connect: ({ addChain, supportedChains, walletType }) =>
     async function connectWalletconnect(
@@ -315,6 +317,38 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
       return toolbox;
     }
 
+    case Chain.Tron: {
+      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const { DEFAULT_TRON_METHODS } = await import("./constants");
+
+      // Create a Tron signer that uses WalletConnect
+      const signer: TronSigner = {
+        getAddress() {
+          return Promise.resolve(address);
+        },
+
+        async signTransaction(transaction: TronTransaction) {
+          if (!walletconnect) {
+            throw new SwapKitError("wallet_walletconnect_connection_not_established");
+          }
+
+          const signedTx = await walletconnect.client.request({
+            topic: session.topic,
+            chainId: chainToChainId(Chain.Tron),
+            request: {
+              method: DEFAULT_TRON_METHODS.TRON_SIGN_TRANSACTION,
+              params: { transaction },
+            },
+          });
+
+          return signedTx as TronSignedTransaction;
+        },
+      };
+
+      const toolbox = await createTronToolbox({ signer });
+      return toolbox;
+    }
+
     default:
       throw new SwapKitError({
         errorKey: "wallet_chain_not_supported",

package/src/walletconnect/namespaces.ts

@@ -11,6 +11,8 @@ import {
   DEFAULT_POLKADOT_METHODS,
   DEFAULT_SOLANA_EVENTS,
   DEFAULT_SOLANA_METHODS,
+  DEFAULT_TRON_EVENTS,
+  DEFAULT_TRON_METHODS,
 } from "./constants";
 
 export const getNamespacesFromChains = (chains: string[]) => {
@@ -37,6 +39,8 @@ export const getSupportedMethodsByNamespace = (namespace: string) => {
       return Object.values(DEFAULT_POLKADOT_METHODS);
     case "near":
       return Object.values(DEFAULT_NEAR_METHODS);
+    case "tron":
+      return Object.values(DEFAULT_TRON_METHODS);
     default:
       throw new SwapKitError({
         errorKey: "wallet_walletconnect_namespace_not_supported",
@@ -57,6 +61,8 @@ export const getSupportedEventsByNamespace = (namespace: string) => {
       return Object.values(DEFAULT_POLKADOT_EVENTS);
     case "near":
       return Object.values(DEFAULT_NEAR_EVENTS);
+    case "tron":
+      return Object.values(DEFAULT_TRON_EVENTS);
     default:
       throw new SwapKitError({
         errorKey: "wallet_walletconnect_namespace_not_supported",

package/src/xaman/README.md

@@ -0,0 +1,66 @@
+# Xaman Wallet Integration
+
+## Configuration
+
+### Option 1: Configure via SKConfig (Recommended)
+
+```typescript
+import { SwapKit } from "@swapkit/core";
+import { SKConfig } from "@swapkit/helpers";
+
+// Set the Xaman API key globally
+SKConfig.setApiKey("xaman", "your-xaman-api-key");
+
+// Or configure during SwapKit initialization
+const swapKit = SwapKit({
+  config: {
+    apiKeys: {
+      xaman: "your-xaman-api-key"
+    }
+  }
+});
+
+// Connect to Xaman wallet
+await swapKit.connectWallet(WalletOption.XAMAN, [Chain.Ripple]);
+```
+
+### Option 2: Pass API key during connection
+
+```typescript
+// Connect with API key override
+await swapKit.connectWallet(WalletOption.XAMAN, [Chain.Ripple], {
+  apiKey: "your-xaman-api-key"
+});
+```
+
+## Usage Example
+
+```typescript
+// Get the connected wallet
+const wallet = swapKit.getWallet(Chain.Ripple);
+
+// Send XRP
+const txHash = await wallet.transfer({
+  assetValue: AssetValue.from({ chain: Chain.Ripple, value: 1 }),
+  recipient: "rN7n7otQDd6FczFgLdSqtcsAUxDkw6fzRH",
+  memo: "Payment memo"
+});
+```
+
+## Destination Tags
+
+For exchange addresses that require destination tags:
+
+```typescript
+// The destination tag should be included in the memo field
+// Format: "DestinationTag:123456"
+const txHash = await wallet.transfer({
+  assetValue: AssetValue.from({ chain: Chain.Ripple, value: 10 }),
+  recipient: "rExchangeAddress...",
+  memo: "DestinationTag:123456"
+});
+```
+
+## Getting an API Key
+
+To use the Xaman wallet, you need to obtain an API key from the [Xaman Developer Console](https://apps.xumm.dev/).

package/src/xaman/helpers.ts

@@ -0,0 +1,59 @@
+import { type AssetValue, Chain, SwapKitError } from "@swapkit/helpers";
+import type { Xumm } from "xumm";
+import { sendXamanTransaction } from "./walletMethods.js";
+
+interface GetWalletForChainParams {
+  chain: Chain;
+  address: string;
+  rpcUrl?: string;
+  xumm: Xumm;
+}
+
+export async function getWalletForChain({ xumm, chain, address, rpcUrl }: GetWalletForChainParams) {
+  switch (chain) {
+    case Chain.Ripple: {
+      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
+
+      // const api = apis?.[chain]; // Unused for now
+      const toolbox = await getRippleToolbox({ rpcUrl });
+
+      // Override transfer method to use Xaman transaction flow
+      const transfer = async (params: {
+        assetValue: AssetValue;
+        recipient: string;
+        memo?: string;
+      }) => {
+        const { recipient, assetValue, memo } = params;
+
+        // Create and subscribe to payment via Xaman
+        const paymentResult = await sendXamanTransaction(xumm, {
+          from: address,
+          destination: recipient,
+          amount: assetValue.getValue("string"),
+          memo: memo,
+        });
+
+        // If not successful or no transaction ID, throw error
+        if (!(paymentResult.result.success && paymentResult.result.transactionId)) {
+          throw new SwapKitError("wallet_xaman_transaction_failed");
+        }
+
+        // Return the transaction ID string
+        return paymentResult.result.transactionId;
+      };
+
+      return {
+        ...toolbox,
+        address,
+        getAddress: () => address,
+        transfer,
+        // Expose Xaman-specific methods
+        createAndSubscribePayment: sendXamanTransaction,
+        disconnect: xumm.logout,
+      };
+    }
+
+    default:
+      throw new SwapKitError("wallet_chain_not_supported", { wallet: "Xaman", chain });
+  }
+}

package/src/xaman/index.ts

@@ -0,0 +1,79 @@
+import {
+  Chain,
+  SKConfig,
+  SwapKitError,
+  WalletOption,
+  createWallet,
+  filterSupportedChains,
+} from "@swapkit/helpers";
+import { Xumm } from "xumm";
+import { getWalletSupportedChains } from "../utils";
+import { getWalletForChain } from "./helpers.js";
+import type { XamanConfig } from "./types.js";
+import { connectXamanWallet as connectXamanWalletMethod } from "./walletMethods.js";
+
+export const xamanWallet = createWallet({
+  name: "connectXaman",
+  walletType: WalletOption.XAMAN,
+  supportedChains: [Chain.Ripple],
+  connect: ({ addChain, supportedChains: walletSupportedChains, walletType }) =>
+    async function connectXamanWallet(chains: Chain[], xamanConfigOverwrite?: XamanConfig) {
+      const supportedChains = filterSupportedChains({
+        chains,
+        supportedChains: walletSupportedChains,
+        walletType,
+      });
+
+      const { xaman: xamanApiKey } = SKConfig.get("apiKeys");
+      const apiKey = xamanConfigOverwrite?.apiKey || xamanApiKey;
+
+      if (!apiKey) {
+        throw new SwapKitError("wallet_missing_api_key", { wallet: "Xaman" });
+      }
+
+      const xumm = new Xumm(apiKey);
+
+      return new Promise<boolean>((resolve, reject) => {
+        xumm.on("success", async () => {
+          try {
+            const address = await connectXamanWalletMethod(xumm);
+
+            const promises = supportedChains.map(async (chain) => {
+              const rpcUrl = SKConfig.get("rpcUrls")[chain];
+              const walletMethods = await getWalletForChain({
+                xumm,
+                chain,
+                address,
+                rpcUrl,
+              });
+
+              addChain({
+                ...walletMethods,
+                chain,
+                balance: [],
+                walletType: WalletOption.XAMAN,
+                address,
+                disconnect: xumm.logout,
+              });
+            });
+
+            await Promise.all(promises);
+            resolve(true);
+          } catch (error) {
+            reject(error);
+          }
+        });
+
+        xumm.on("error", (error) => {
+          reject(error);
+        });
+
+        xumm.authorize();
+      });
+    },
+});
+
+export const XAMAN_SUPPORTED_CHAINS = getWalletSupportedChains(xamanWallet);
+export type XamanSupportedChain = (typeof XAMAN_SUPPORTED_CHAINS)[number];
+
+export type { XamanConfig } from "./types.js";

package/src/xaman/types.ts

@@ -0,0 +1,26 @@
+export interface XamanConfig {
+  apiKey: string;
+}
+
+export interface XamanPaymentParams {
+  destination: string;
+  from: string;
+  amount: string;
+  memo?: string;
+  destinationTag?: number;
+}
+
+export interface XamanPaymentResult {
+  payloadId: string;
+  qrCode: string;
+  deepLink: string;
+  websocketUrl: string;
+  result: XamanTransactionResult;
+}
+
+export interface XamanTransactionResult {
+  success: boolean;
+  transactionId?: string;
+  account?: string;
+  reason?: string;
+}