@swapkit/wallets 4.0.0-beta.53 → 4.0.0-beta.55

package/src/walletconnect/index.ts

@@ -1,460 +0,0 @@
-import type { StdSignDoc } from "@cosmjs/amino";
-import {
-  Chain,
-  ChainId,
-  type GenericTransferParams,
-  SKConfig,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} 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";
-
-import type { SignClient } from "@walletconnect/sign-client";
-import { getWalletSupportedChains } from "../utils";
-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({
-  name: "connectWalletconnect",
-  walletType: WalletOption.WALLETCONNECT,
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Aurora,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.Berachain,
-    Chain.BinanceSmartChain,
-    Chain.Cosmos,
-    Chain.Ethereum,
-    Chain.Kujira,
-    Chain.Maya,
-    Chain.Near,
-    Chain.Optimism,
-    Chain.Polygon,
-    Chain.THORChain,
-    Chain.Tron,
-  ],
-  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;
-    },
-});
-
-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.Optimism:
-    case Chain.Polygon: {
-      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-
-      const provider = await getProvider(chain);
-      const signer = await getEVMSigner({ walletconnect, chain, provider });
-      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.THORChain);
-
-      async function getAccount(accountAddress: string) {
-        const cosmosToolbox = toolbox;
-        const account = await (
-          cosmosToolbox as Awaited<ReturnType<typeof createThorchainToolbox>>
-        ).getAccount(accountAddress);
-
-        if (chain !== Chain.THORChain) {
-          return account;
-        }
-
-        const [{ address, algo, pubkey }] = (await walletconnect?.client.request({
-          chainId: THORCHAIN_MAINNET_ID,
-          // @ts-ignore
-          topic: session.topic,
-          request: {
-            method: DEFAULT_COSMOS_METHODS.COSMOS_GET_ACCOUNTS,
-            params: {},
-          },
-        })) as [{ address: string; algo: string; pubkey: string }];
-
-        return { ...account, address, pubkey: { type: algo, value: pubkey } };
-      }
-
-      const fee = getDefaultChainFee(chain);
-
-      const signRequest = (signDoc: StdSignDoc) =>
-        walletconnect?.client.request({
-          chainId: THORCHAIN_MAINNET_ID,
-          topic: session.topic,
-          request: {
-            method: DEFAULT_COSMOS_METHODS.COSMOS_SIGN_AMINO,
-            params: { signerAddress: address, signDoc },
-          },
-        });
-
-      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({ assetValue, memo, sender: address, ...rest })];
-
-        const chainId = ChainId.THORChain;
-
-        const signDoc = makeSignDoc(
-          msgs,
-          fee,
-          chainId,
-          memo,
-          accountNumber?.toString(),
-          sequence?.toString() || "0",
-        );
-
-        const signature: any = await signRequest(signDoc);
-
-        const bodyBytes = await buildEncodedTxBody({
-          chain: Chain.THORChain,
-          msgs: msgs.map(parseAminoMessageForDirectSigning),
-          memo: memo || "",
-        });
-        const pubkey = encodePubkey(account.pubkey);
-        const authInfoBytes = makeAuthInfoBytes(
-          [{ pubkey, sequence }],
-          fee.amount,
-          Number.parseInt(fee.gas),
-          undefined,
-          undefined,
-          SignMode.SIGN_MODE_LEGACY_AMINO_JSON,
-        );
-
-        const txRaw = TxRaw.fromPartial({
-          bodyBytes,
-          authInfoBytes,
-          signatures: [
-            fromBase64(
-              typeof signature.signature === "string"
-                ? signature.signature
-                : signature.signature.signature,
-            ),
-          ],
-        });
-        const txBytes = TxRaw.encode(txRaw).finish();
-
-        const broadcaster = await createStargateClient(SKConfig.get("rpcUrls")[Chain.THORChain]);
-        const result = await broadcaster.broadcastTx(txBytes);
-        return result.transactionHash;
-      }
-
-      return {
-        ...toolbox,
-        transfer: (params: GenericTransferParams) => thorchainTransfer(params),
-        deposit: (params: ThorchainDepositParams) => thorchainTransfer(params),
-        getAccount,
-      };
-    }
-
-    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 = {
-        getPublicKey() {
-          // WalletConnect NEAR doesn't expose public key directly
-          return Promise.reject(
-            new SwapKitError("wallet_walletconnect_method_not_supported", {
-              method: "getPublicKey",
-            }),
-          );
-        },
-
-        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({
-            topic: session.topic,
-            chainId: chainToChainId(Chain.Near),
-            request: {
-              method: DEFAULT_NEAR_METHODS.NEAR_SIGN_AND_SEND_TRANSACTION,
-              params: { transaction },
-            },
-          });
-          // Return dummy hash and result
-          return [new Uint8Array(32), result];
-        },
-
-        signDelegateAction(_delegateAction: any) {
-          return Promise.reject(
-            new SwapKitError("wallet_walletconnect_method_not_supported", {
-              method: "signDelegateAction",
-            }),
-          );
-        },
-
-        getAddress() {
-          return Promise.resolve(address);
-        },
-      } 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({
-            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",
-        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 {
-    if (!walletConnectProjectId) {
-      throw new SwapKitError("wallet_walletconnect_project_id_not_specified");
-    }
-    const requiredNamespaces = getRequiredNamespaces(chains.map(chainToChainId));
-
-    const { SignClient } = await import("@walletconnect/sign-client");
-    const { WalletConnectModal } = await import("@walletconnect/modal");
-
-    const client = new SignClient({
-      logger: DEFAULT_LOGGER,
-      relayUrl: DEFAULT_RELAY_URL,
-      projectId: walletConnectProjectId,
-      metadata: walletconnectOptions?.metadata || DEFAULT_APP_METADATA,
-      ...walletconnectOptions?.core,
-    });
-
-    const modal = new WalletConnectModal({
-      logger: DEFAULT_LOGGER,
-      relayUrl: DEFAULT_RELAY_URL,
-      projectId: walletConnectProjectId,
-      ...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({
-        topic: oldSession.topic,
-        reason: { code: 0, message: "Resetting session" },
-      });
-    }
-
-    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({
-          topic: session.topic,
-          reason: { code: 0, message: "User disconnected" },
-        }));
-    };
-
-    if (!session) {
-      throw new SwapKitError("wallet_walletconnect_connection_not_established");
-    }
-
-    return { signer, session, accounts, client, disconnect };
-  } catch (_e) {
-    // Errors are handled by returning undefined
-  } finally {
-    if (modal) {
-      modal.closeModal();
-    }
-  }
-  return undefined;
-}

package/src/walletconnect/namespaces.ts

@@ -1,87 +0,0 @@
-import type { ProposalTypes } from "@walletconnect/types";
-
-import { SwapKitError } from "@swapkit/helpers";
-import {
-  DEFAULT_COSMOS_METHODS,
-  DEFAULT_EIP155_METHODS,
-  DEFAULT_EIP_155_EVENTS,
-  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,
-      {
-        methods: getSupportedMethodsByNamespace(namespace),
-        chains: chains.filter((chain) => chain.startsWith(namespace)),
-        events: getSupportedEventsByNamespace(namespace) as any[],
-      },
-    ]),
-  );
-};

package/src/walletconnect/types.ts

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

package/src/xaman/README.md

@@ -1,66 +0,0 @@
-# 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

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