@tcswap/wallets 4.3.16

package/src/xaman/helpers.ts

@@ -0,0 +1,58 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { type AssetValue, Chain, USwapError } from "@tcswap/helpers";
+import type { Xumm } from "xumm";
+import { sendXamanTransaction } from "./walletMethods";
+
+interface GetWalletForChainParams {
+  chain: Chain;
+  address: string;
+  xumm: Xumm;
+}
+
+export async function getWalletForChain({ xumm, chain, address }: GetWalletForChainParams) {
+  switch (chain) {
+    case Chain.Ripple: {
+      const { getRippleToolbox } = await import("@tcswap/toolboxes/ripple");
+
+      // const api = apis?.[chain]; // Unused for now
+      const toolbox = await getRippleToolbox({});
+
+      // 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, {
+          amount: assetValue.getValue("string"),
+          destination: recipient,
+          from: address,
+          memo: memo,
+        });
+
+        // If not successful or no transaction ID, throw error
+        if (!(paymentResult.result.success && paymentResult.result.transactionId)) {
+          throw new USwapError("wallet_xaman_transaction_failed");
+        }
+
+        // Return the transaction ID string
+        return paymentResult.result.transactionId;
+      };
+
+      return {
+        ...toolbox,
+        address,
+        // Expose Xaman-specific methods
+        createAndSubscribePayment: sendXamanTransaction,
+        disconnect: xumm.logout,
+        getAddress: () => address,
+        transfer,
+      };
+    }
+
+    default:
+      throw new USwapError("wallet_chain_not_supported", { chain, wallet: "Xaman" });
+  }
+}

package/src/xaman/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain, filterSupportedChains, USwapConfig, USwapError, WalletOption } from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+import { Xumm } from "xumm";
+import { getWalletForChain } from "./helpers";
+import type { XamanConfig } from "./types";
+import { connectXamanWallet as connectXamanWalletMethod } from "./walletMethods";
+
+export const xamanWallet = createWallet({
+  connect: ({ addChain, supportedChains: walletSupportedChains, walletType }) =>
+    function connectXamanWallet(chains: Chain[], xamanConfigOverwrite?: XamanConfig) {
+      const supportedChains = filterSupportedChains({ chains, supportedChains: walletSupportedChains, walletType });
+
+      const { xaman: xamanApiKey } = USwapConfig.get("apiKeys");
+      const apiKey = xamanConfigOverwrite?.apiKey || xamanApiKey;
+
+      if (!apiKey) {
+        throw new USwapError("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 walletMethods = await getWalletForChain({ address, chain, xumm });
+
+              addChain({
+                ...walletMethods,
+                address,
+                balance: [],
+                chain,
+                disconnect: xumm.logout,
+                walletType: WalletOption.XAMAN,
+              });
+            });
+
+            await Promise.all(promises);
+            resolve(true);
+          } catch (error) {
+            reject(error);
+          }
+        });
+
+        xumm.on("error", (error) => {
+          reject(error);
+        });
+
+        xumm.authorize();
+      });
+    },
+  name: "connectXaman",
+  supportedChains: [Chain.Ripple],
+  walletType: WalletOption.XAMAN,
+});
+
+export const XAMAN_SUPPORTED_CHAINS = getWalletSupportedChains(xamanWallet);
+export type XamanSupportedChain = (typeof XAMAN_SUPPORTED_CHAINS)[number];
+
+export type { XamanConfig } from "./types";

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

package/src/xaman/walletMethods.ts

@@ -0,0 +1,114 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { USwapError } from "@tcswap/helpers";
+import type { Xumm } from "xumm";
+import type { XamanPaymentParams } from "./types";
+
+export const connectXamanWallet = async (xumm: Xumm) => {
+  if (!xumm) {
+    throw new USwapError("wallet_xaman_not_configured");
+  }
+
+  try {
+    const user = await xumm.user;
+    const account = await user?.account;
+
+    if (account) {
+      return account;
+    }
+
+    throw new USwapError("wallet_xaman_auth_failed");
+  } catch (error) {
+    console.error("Xaman wallet connection failed:", error);
+    throw new USwapError("wallet_xaman_connection_failed");
+  }
+};
+
+export const sendXamanTransaction = async (xumm: Xumm, params: XamanPaymentParams) => {
+  try {
+    // Validate required parameters
+    if (!(params.destination && params.amount && params.from)) {
+      throw new USwapError("wallet_xaman_connection_failed");
+    }
+
+    // Convert XRP to drops (1 XRP = 1,000,000 drops)
+    const amountInDrops = (Number.parseFloat(params.amount) * 1000000).toString();
+
+    // Create transaction object
+    const transaction = {
+      Account: params.from,
+      Amount: amountInDrops,
+      Destination: params.destination,
+      TransactionType: "Payment" as const,
+      ...(params.destinationTag !== undefined && { DestinationTag: params.destinationTag }),
+      ...(params.memo && {
+        Memos: [{ Memo: { MemoData: Buffer.from(params.memo, "utf8").toString("hex").toUpperCase() } }],
+      }),
+    };
+
+    // Create and subscribe to payload following the official example
+    const subscription = await xumm.payload?.createAndSubscribe(transaction, (event) => {
+      if ("signed" in event.data) {
+        // Return event.data to close subscription and resolve promise
+        return event.data; // { signed: true|false, payload_uuidv4: '...' }
+      }
+      return undefined;
+    });
+
+    if (!subscription) {
+      throw new USwapError("wallet_xaman_transaction_failed");
+    }
+
+    const { created } = subscription;
+
+    // Handle payload presentation based on runtime environment
+    if (xumm.runtime?.xapp) {
+      xumm.xapp?.openSignRequest(created);
+    } else if (typeof window !== "undefined") {
+      const url =
+        created.pushed && created.next?.no_push_msg_received ? created.next.no_push_msg_received : created.next?.always;
+      if (url) window.open(url);
+    }
+
+    // Wait until the user signed/rejected
+    const resolved = await subscription.resolved;
+
+    if (!resolved || typeof resolved !== "object" || !("signed" in resolved) || !resolved.signed) {
+      throw new USwapError("wallet_xaman_transaction_failed");
+    }
+
+    // Fetch the full payload result using the UUID from resolved data
+    const payloadDetails = await xumm.payload?.get((resolved as any).payload_uuidv4);
+
+    if (!payloadDetails) {
+      throw new USwapError("wallet_xaman_monitoring_failed");
+    }
+
+    // Extract transaction ID from response
+    const transactionId = payloadDetails.response?.txid || "";
+    const account = payloadDetails.response?.account || "";
+
+    if (!transactionId) {
+      throw new USwapError("wallet_xaman_transaction_failed");
+    }
+
+    // Return comprehensive result
+    return {
+      deepLink: created.next?.always || "",
+      // Initial payload info for QR codes, deep links, etc.
+      payloadId: created.uuid || "",
+      qrCode: created.refs?.qr_png || "",
+      // Final transaction result - SUCCESS with tx hash
+      result: { account, reason: undefined, success: true, transactionId },
+      websocketUrl: created.refs?.websocket_status || "",
+    };
+  } catch (error) {
+    console.error("Xaman payment creation and subscription failed:", error);
+    if (error instanceof USwapError) {
+      throw error;
+    }
+    throw new USwapError("wallet_xaman_transaction_failed");
+  }
+};