@swapkit/wallets 4.3.11 → 4.6.0

package/src/walletconnect/index.ts

@@ -1,392 +0,0 @@
-import type { StdSignDoc } from "@cosmjs/amino";
-import type { Transaction } from "@near-js/transactions";
-import {
-  Chain,
-  filterSupportedChains,
-  type GenericTransferParams,
-  getRPCUrl,
-  SKConfig,
-  SwapKitError,
-  WalletOption,
-} from "@swapkit/helpers";
-import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
-import type { NearSigner } from "@swapkit/toolboxes/near";
-import type { TronSignedTransaction, TronSigner, TronTransaction } from "@swapkit/toolboxes/tron";
-import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
-import type { WalletConnectModal } from "@walletconnect/modal";
-import type { SignClient } from "@walletconnect/sign-client";
-import type { SessionTypes, SignClientTypes } from "@walletconnect/types";
-import {
-  DEFAULT_APP_METADATA,
-  DEFAULT_COSMOS_METHODS,
-  DEFAULT_LOGGER,
-  DEFAULT_RELAY_URL,
-  THORCHAIN_MAINNET_ID,
-} from "./constants";
-import { getEVMSigner } from "./evmSigner";
-import { chainToChainId, getAddressByChain } from "./helpers";
-import { getRequiredNamespaces } from "./namespaces";
-
-export * from "./constants";
-export * from "./types";
-
-export const walletconnectWallet = createWallet({
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectWalletconnect(chains: Chain[], walletconnectOptions?: SignClientTypes.Options) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const { walletConnectProjectId } = SKConfig.get("apiKeys");
-
-      if (!walletConnectProjectId) {
-        throw new SwapKitError("wallet_walletconnect_project_id_not_specified");
-      }
-
-      const walletconnect = await getWalletconnect(filteredChains, walletConnectProjectId, walletconnectOptions);
-
-      if (!walletconnect) {
-        throw new SwapKitError("wallet_walletconnect_connection_not_established");
-      }
-
-      const { accounts } = walletconnect;
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const address = getAddressByChain(chain, accounts || []);
-          const toolbox = await getToolbox({ address, chain, walletconnect });
-
-          addChain({
-            ...toolbox,
-            address,
-            chain,
-            disconnect: walletconnect.disconnect,
-            walletType: WalletOption.WALLETCONNECT,
-          });
-        }),
-      );
-
-      return true;
-    },
-  name: "connectWalletconnect",
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Aurora,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.Berachain,
-    Chain.BinanceSmartChain,
-    Chain.Cosmos,
-    Chain.Ethereum,
-    Chain.Kujira,
-    Chain.Maya,
-    Chain.Monad,
-    Chain.Near,
-    Chain.Optimism,
-    Chain.Polygon,
-    Chain.THORChain,
-    Chain.Tron,
-    Chain.XLayer,
-  ],
-  walletType: WalletOption.WALLETCONNECT,
-});
-
-export const WC_SUPPORTED_CHAINS = getWalletSupportedChains(walletconnectWallet);
-export type Walletconnect = Awaited<ReturnType<typeof getWalletconnect>>;
-
-async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
-  chain,
-  walletconnect,
-  address,
-}: {
-  walletconnect: Walletconnect;
-  chain: T;
-  address: string;
-}) {
-  const session = walletconnect?.session;
-  if (!session) {
-    throw new SwapKitError("wallet_walletconnect_connection_not_established");
-  }
-
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Monad:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.XLayer: {
-      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-
-      const provider = await getProvider(chain);
-      const signer = await getEVMSigner({ chain, provider, walletconnect });
-      const toolbox = await getEvmToolbox(chain, { provider, signer });
-
-      return toolbox;
-    }
-
-    case Chain.THORChain: {
-      const { SignMode } = await import("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
-      const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx.js");
-
-      const importedSigning = await import("@cosmjs/proto-signing");
-      const encodePubkey = importedSigning.encodePubkey ?? importedSigning.default?.encodePubkey;
-      const makeAuthInfoBytes = importedSigning.makeAuthInfoBytes ?? importedSigning.default?.makeAuthInfoBytes;
-      const importedAmino = await import("@cosmjs/amino");
-      const makeSignDoc = importedAmino.makeSignDoc ?? importedSigning.default?.makeSignDoc;
-
-      const {
-        getCosmosToolbox,
-        buildAminoMsg,
-        buildEncodedTxBody,
-        createStargateClient,
-        fromBase64,
-        getDefaultChainFee,
-        parseAminoMessageForDirectSigning,
-      } = await import("@swapkit/toolboxes/cosmos");
-      const toolbox = await getCosmosToolbox(chain);
-
-      const fee = getDefaultChainFee(chain);
-
-      const signRequest = (signDoc: StdSignDoc) =>
-        walletconnect?.client.request({
-          chainId: THORCHAIN_MAINNET_ID,
-          request: { method: DEFAULT_COSMOS_METHODS.COSMOS_SIGN_AMINO, params: { signDoc, signerAddress: address } },
-          topic: session.topic,
-        });
-
-      async function thorchainTransfer({ assetValue, memo, ...rest }: GenericTransferParams | ThorchainDepositParams) {
-        const account = await toolbox.getAccount(address);
-        if (!account) {
-          throw new SwapKitError({ errorKey: "wallet_missing_params", info: { account } });
-        }
-
-        if (!account.pubkey) {
-          throw new SwapKitError({ errorKey: "wallet_missing_params", info: { account, pubkey: account?.pubkey } });
-        }
-
-        const { accountNumber, sequence = 0 } = account;
-
-        const msgs = [buildAminoMsg({ ...rest, assetValue, memo, sender: address })];
-
-        const signDoc = makeSignDoc(
-          msgs,
-          fee,
-          assetValue.chainId,
-          memo,
-          accountNumber?.toString(),
-          sequence?.toString() || "0",
-        );
-
-        const signature: any = await signRequest(signDoc);
-
-        const bodyBytes = await buildEncodedTxBody({
-          chain: Chain.THORChain,
-          memo: memo || "",
-          msgs: msgs.map(parseAminoMessageForDirectSigning),
-        });
-        const pubkey = encodePubkey(account.pubkey);
-        const authInfoBytes = makeAuthInfoBytes(
-          [{ pubkey, sequence }],
-          fee.amount,
-          Number.parseInt(fee.gas, 10),
-          undefined,
-          undefined,
-          SignMode.SIGN_MODE_LEGACY_AMINO_JSON,
-        );
-
-        const txRaw = TxRaw.fromPartial({
-          authInfoBytes,
-          bodyBytes,
-          signatures: [
-            fromBase64(typeof signature.signature === "string" ? signature.signature : signature.signature.signature),
-          ],
-        });
-        const txBytes = TxRaw.encode(txRaw).finish();
-
-        const rpcUrl = await getRPCUrl(Chain.THORChain);
-        const broadcaster = await createStargateClient(rpcUrl);
-        const result = await broadcaster.broadcastTx(txBytes);
-        return result.transactionHash;
-      }
-
-      return {
-        ...toolbox,
-        deposit: (params: ThorchainDepositParams) => thorchainTransfer(params),
-        transfer: (params: GenericTransferParams) => thorchainTransfer(params),
-      };
-    }
-
-    case Chain.Near: {
-      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
-      const { DEFAULT_NEAR_METHODS } = await import("./constants");
-
-      // Create a NEAR signer that uses WalletConnect
-      const signer = {
-        getAddress() {
-          return Promise.resolve(address);
-        },
-        getPublicKey() {
-          // WalletConnect NEAR doesn't expose public key directly
-          return Promise.reject(
-            new SwapKitError("wallet_walletconnect_method_not_supported", { method: "getPublicKey" }),
-          );
-        },
-
-        signDelegateAction(_delegateAction: any) {
-          return Promise.reject(
-            new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signDelegateAction" }),
-          );
-        },
-
-        signNep413Message(
-          _message: string,
-          _accountId: string,
-          _recipient: string,
-          _nonce: Uint8Array,
-          _callbackUrl?: string,
-        ) {
-          // WalletConnect NEAR spec doesn't include NEP-413 message signing
-          return Promise.reject(
-            new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signNep413Message" }),
-          );
-        },
-
-        async signTransaction(transaction: Transaction) {
-          if (!walletconnect) {
-            throw new SwapKitError("wallet_walletconnect_connection_not_established");
-          }
-          // WalletConnect signs and sends in one operation
-          const result = await walletconnect.client.request({
-            chainId: chainToChainId(Chain.Near),
-            request: { method: DEFAULT_NEAR_METHODS.NEAR_SIGN_AND_SEND_TRANSACTION, params: { transaction } },
-            topic: session.topic,
-          });
-          // Return dummy hash and result
-          return [new Uint8Array(32), result];
-        },
-      } as NearSigner;
-
-      const toolbox = await getNearToolbox({ signer });
-      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({
-            chainId: chainToChainId(Chain.Tron),
-            request: { method: DEFAULT_TRON_METHODS.TRON_SIGN_TRANSACTION, params: { transaction } },
-            topic: session.topic,
-          });
-
-          return signedTx as TronSignedTransaction;
-        },
-      };
-
-      const toolbox = await createTronToolbox({ signer });
-      return toolbox;
-    }
-
-    default:
-      throw new SwapKitError({
-        errorKey: "wallet_chain_not_supported",
-        info: { chain, wallet: WalletOption.WALLETCONNECT },
-      });
-  }
-}
-
-async function getWalletconnect(
-  chains: Chain[],
-  walletConnectProjectId: string,
-  walletconnectOptions?: SignClientTypes.Options,
-) {
-  let modal: WalletConnectModal | undefined;
-  let signer: typeof SignClient | undefined;
-  let session: SessionTypes.Struct | undefined;
-  let accounts: string[] | undefined;
-  try {
-    const requiredNamespaces = getRequiredNamespaces(chains.map(chainToChainId));
-
-    const { SignClient } = await import("@walletconnect/sign-client");
-    const { WalletConnectModal } = await import("@walletconnect/modal");
-
-    const client = await SignClient.init({
-      logger: DEFAULT_LOGGER,
-      metadata: walletconnectOptions?.metadata || DEFAULT_APP_METADATA,
-      projectId: walletConnectProjectId,
-      relayUrl: DEFAULT_RELAY_URL,
-      ...walletconnectOptions?.core,
-    });
-
-    const modal = new WalletConnectModal({
-      logger: DEFAULT_LOGGER,
-      projectId: walletConnectProjectId,
-      relayUrl: DEFAULT_RELAY_URL,
-      ...walletconnectOptions?.core,
-    });
-
-    const oldSession = (await client.session.getAll())[0];
-
-    // disconnect old Session cause we can't handle using it with current ui
-    if (oldSession) {
-      await client.disconnect({ reason: { code: 0, message: "Resetting session" }, topic: oldSession.topic });
-    }
-
-    const { uri, approval } = await client.connect({
-      // Optionally: pass a known prior pairing (e.g. from `client.core.pairing.getPairings()`) to skip the `uri` step.
-      //   pairingTopic: pairing?.topic,
-      // Provide the namespaces and chains (e.g. `eip155` for EVM-based chains) we want to use in this session.
-      requiredNamespaces,
-    });
-
-    if (uri) {
-      modal.openModal({ uri });
-      // Await session approval from the wallet.
-      session = await approval();
-      // Handle the returned session (e.g. update UI to "connected" state).
-      // Close the QRCode modal in case it was open.
-      modal.closeModal();
-
-      function extractAccountsFromSession(session: SessionTypes.Struct) {
-        const accounts: string[] = [];
-
-        for (const [_namespace, data] of Object.entries(session.namespaces)) {
-          accounts.push(...data.accounts);
-        }
-
-        return accounts;
-      }
-
-      accounts = extractAccountsFromSession(session);
-    }
-
-    const disconnect = async () => {
-      session && (await client.disconnect({ reason: { code: 0, message: "User disconnected" }, topic: session.topic }));
-    };
-
-    if (!session) {
-      throw new SwapKitError("wallet_walletconnect_connection_not_established");
-    }
-
-    return { accounts, client, disconnect, session, signer };
-  } catch {
-    // Errors are handled by returning undefined
-  } finally {
-    if (modal) {
-      modal.closeModal();
-    }
-  }
-  return undefined;
-}

package/src/walletconnect/namespaces.ts

@@ -1,80 +0,0 @@
-import { SwapKitError } from "@swapkit/helpers";
-import type { ProposalTypes } from "@walletconnect/types";
-import {
-  DEFAULT_COSMOS_METHODS,
-  DEFAULT_EIP_155_EVENTS,
-  DEFAULT_EIP155_METHODS,
-  DEFAULT_NEAR_EVENTS,
-  DEFAULT_NEAR_METHODS,
-  DEFAULT_POLKADOT_EVENTS,
-  DEFAULT_POLKADOT_METHODS,
-  DEFAULT_SOLANA_EVENTS,
-  DEFAULT_SOLANA_METHODS,
-  DEFAULT_TRON_EVENTS,
-  DEFAULT_TRON_METHODS,
-} from "./constants";
-
-export const getNamespacesFromChains = (chains: string[]) => {
-  const supportedNamespaces: string[] = [];
-  for (const chainId of chains) {
-    const [namespace] = chainId.split(":");
-    if (namespace && !supportedNamespaces.includes(namespace)) {
-      supportedNamespaces.push(namespace);
-    }
-  }
-
-  return supportedNamespaces;
-};
-
-export const getSupportedMethodsByNamespace = (namespace: string) => {
-  switch (namespace) {
-    case "eip155":
-      return Object.values(DEFAULT_EIP155_METHODS);
-    case "cosmos":
-      return Object.values(DEFAULT_COSMOS_METHODS);
-    case "solana":
-      return Object.values(DEFAULT_SOLANA_METHODS);
-    case "polkadot":
-      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", info: { namespace } });
-  }
-};
-
-export const getSupportedEventsByNamespace = (namespace: string) => {
-  switch (namespace) {
-    case "eip155":
-      return Object.values(DEFAULT_EIP_155_EVENTS);
-    case "cosmos":
-      return [];
-    case "solana":
-      return Object.values(DEFAULT_SOLANA_EVENTS);
-    case "polkadot":
-      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", info: { namespace } });
-  }
-};
-
-export const getRequiredNamespaces = (chains: string[]): ProposalTypes.RequiredNamespaces => {
-  const selectedNamespaces = getNamespacesFromChains(chains);
-
-  return Object.fromEntries(
-    selectedNamespaces.map((namespace) => [
-      namespace,
-      {
-        chains: chains.filter((chain) => chain.startsWith(namespace)),
-        events: getSupportedEventsByNamespace(namespace) as any[],
-        methods: getSupportedMethodsByNamespace(namespace),
-      },
-    ]),
-  );
-};

package/src/walletconnect/types.ts

@@ -1,6 +0,0 @@
-export interface ClientMetadata {
-  name: string;
-  description: string;
-  url: string;
-  icons: string[];
-}

package/src/xaman/helpers.ts

@@ -1,54 +0,0 @@
-import { type AssetValue, Chain, SwapKitError } from "@swapkit/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("@swapkit/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 SwapKitError("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 SwapKitError("wallet_chain_not_supported", { chain, wallet: "Xaman" });
-  }
-}

package/src/xaman/index.ts

@@ -1,62 +0,0 @@
-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();
-      });
-    },
-  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

@@ -1,26 +0,0 @@
-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;
-}