@swapkit/wallets 4.8.0 → 4.8.1

package/src/xaman/helpers.ts

@@ -0,0 +1,89 @@
+import { type AssetValue, Chain, SwapKitError } from "@swapkit/helpers";
+import { match } from "ts-pattern";
+import type { Xumm } from "xumm";
+import { sendXamanTransaction, sendXamanTrustSet, submitXamanPayload } from "./walletMethods";
+
+interface GetWalletForChainParams {
+  chain: Chain;
+  address: string;
+  xumm: Xumm;
+}
+
+export function getWalletForChain({ xumm, chain, address }: GetWalletForChainParams) {
+  return match(chain)
+    .with(Chain.Ripple, async () => {
+      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
+
+      const signer = {
+        getAddress: () => address,
+        signTransaction: async (jsonTx: Record<string, unknown>) => {
+          const txjson = { ...jsonTx, Account: jsonTx.Account ?? address };
+          const submitted = await submitXamanPayload(xumm, txjson, { submit: false });
+
+          if (!submitted.result.hex) {
+            throw new SwapKitError("wallet_xaman_transaction_failed");
+          }
+
+          return { hash: submitted.result.transactionId, tx_blob: submitted.result.hex };
+        },
+      };
+
+      const toolbox = await getRippleToolbox({ signer });
+
+      const transfer = async ({
+        assetValue,
+        recipient,
+        memo,
+        destinationTag,
+      }: {
+        assetValue: AssetValue;
+        recipient: string;
+        memo?: string;
+        destinationTag?: number;
+      }) => {
+        const isTokenTransfer = !assetValue.isGasAsset;
+
+        if (isTokenTransfer && (!assetValue.ticker || !assetValue.address)) {
+          throw new SwapKitError("wallet_xaman_transaction_failed");
+        }
+
+        const paymentResult = await sendXamanTransaction(xumm, {
+          amount: assetValue.getValue("string"),
+          destination: recipient,
+          destinationTag,
+          from: address,
+          memo,
+          ...(isTokenTransfer && { currency: assetValue.ticker, issuer: assetValue.address }),
+        });
+
+        if (!(paymentResult.result.success && paymentResult.result.transactionId)) {
+          throw new SwapKitError("wallet_xaman_transaction_failed");
+        }
+
+        return paymentResult.result.transactionId;
+      };
+
+      const setTrustLine = async (params: { currency: string; issuer: string; limit: string }) => {
+        const trustSetResult = await sendXamanTrustSet(xumm, { ...params, from: address });
+
+        if (!(trustSetResult.result.success && trustSetResult.result.transactionId)) {
+          throw new SwapKitError("wallet_xaman_transaction_failed");
+        }
+
+        return trustSetResult.result.transactionId;
+      };
+
+      return {
+        ...toolbox,
+        address,
+        createAndSubscribePayment: sendXamanTransaction,
+        disconnect: xumm.logout,
+        getAddress: () => address,
+        setTrustLine,
+        transfer,
+      };
+    })
+    .otherwise(() => {
+      throw new SwapKitError("wallet_chain_not_supported", { chain, wallet: "Xaman" });
+    });
+}

package/src/xaman/index.ts

@@ -0,0 +1,63 @@
+import { Chain, filterSupportedChains, SKConfig, SwapKitError, WalletOption } from "@swapkit/helpers";
+import { createWallet, getWalletSupportedChains } from "@swapkit/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 } = 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 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();
+      });
+    },
+  directSigningSupport: { [Chain.Ripple]: true },
+  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, XamanPaymentParams, XamanTrustSetParams } from "./types";

package/src/xaman/types.ts

@@ -0,0 +1,35 @@
+export interface XamanConfig {
+  apiKey: string;
+}
+
+export interface XamanPaymentParams {
+  destination: string;
+  from: string;
+  amount: string;
+  memo?: string;
+  destinationTag?: number;
+  currency?: string;
+  issuer?: string;
+}
+
+export interface XamanTrustSetParams {
+  from: string;
+  currency: string;
+  issuer: string;
+  limit: string;
+}
+
+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,117 @@
+import { SwapKitError } from "@swapkit/helpers";
+import type { Xumm } from "xumm";
+import type { XamanPaymentParams, XamanTrustSetParams } from "./types";
+
+export const connectXamanWallet = async (xumm: Xumm) => {
+  if (!xumm) {
+    throw new SwapKitError("wallet_xaman_not_configured");
+  }
+
+  try {
+    const user = await xumm.user;
+    const account = await user?.account;
+
+    if (account) {
+      return account;
+    }
+
+    throw new SwapKitError("wallet_xaman_auth_failed");
+  } catch {
+    throw new SwapKitError("wallet_xaman_connection_failed");
+  }
+};
+
+export async function submitXamanPayload(
+  xumm: Xumm,
+  txjson: Record<string, unknown>,
+  { submit = true }: { submit?: boolean } = {},
+) {
+  const payload = (submit ? txjson : { options: { submit: false }, txjson }) as Parameters<
+    NonNullable<Xumm["payload"]>["createAndSubscribe"]
+  >[0];
+
+  const subscription = await xumm.payload?.createAndSubscribe(payload, (event) => {
+    if ("signed" in event.data) return event.data;
+    return undefined;
+  });
+
+  if (!subscription) {
+    throw new SwapKitError("wallet_xaman_transaction_failed");
+  }
+
+  const { created } = subscription;
+
+  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);
+  }
+
+  const resolved = await subscription.resolved;
+
+  if (!resolved || typeof resolved !== "object" || !("signed" in resolved) || !resolved.signed) {
+    throw new SwapKitError("wallet_xaman_transaction_failed");
+  }
+
+  const payloadDetails = await xumm.payload?.get((resolved as any).payload_uuidv4);
+
+  if (!payloadDetails) {
+    throw new SwapKitError("wallet_xaman_monitoring_failed");
+  }
+
+  const transactionId = payloadDetails.response?.txid || "";
+  const account = payloadDetails.response?.account || "";
+  const hex = payloadDetails.response?.hex || "";
+
+  if (!transactionId) {
+    throw new SwapKitError("wallet_xaman_transaction_failed");
+  }
+
+  return {
+    deepLink: created.next?.always || "",
+    payloadId: created.uuid || "",
+    qrCode: created.refs?.qr_png || "",
+    result: { account, hex, reason: undefined, success: true, transactionId },
+    websocketUrl: created.refs?.websocket_status || "",
+  };
+}
+
+export async function sendXamanTransaction(xumm: Xumm, params: XamanPaymentParams) {
+  if (!(params.destination && params.amount && params.from)) {
+    throw new SwapKitError("wallet_xaman_connection_failed");
+  }
+
+  const isTokenTransfer = params.currency && params.issuer;
+  const amount = isTokenTransfer
+    ? { currency: params.currency, issuer: params.issuer, value: params.amount }
+    : (Number.parseFloat(params.amount) * 1000000).toString();
+
+  const transaction = {
+    Account: params.from,
+    Amount: amount,
+    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() } }],
+    }),
+  };
+
+  return await submitXamanPayload(xumm, transaction);
+}
+
+export async function sendXamanTrustSet(xumm: Xumm, params: XamanTrustSetParams) {
+  if (!(params.from && params.currency && params.issuer && params.limit !== undefined)) {
+    throw new SwapKitError("wallet_xaman_connection_failed");
+  }
+
+  const transaction = {
+    Account: params.from,
+    LimitAmount: { currency: params.currency, issuer: params.issuer, value: params.limit },
+    TransactionType: "TrustSet" as const,
+  };
+
+  return await submitXamanPayload(xumm, transaction);
+}