@sodax/wallet-sdk-react 1.5.7-beta → 2.0.0-rc.10

package/src/xchains/icon/IconXService.ts

@@ -1,117 +0,0 @@
-import { XService } from '@/core/XService';
-import type { IconService } from 'icon-sdk-js';
-import * as IconSdkRaw from 'icon-sdk-js';
-import type { XToken } from '@sodax/types';
-import { isNativeToken } from '@/utils';
-
-const IconSdk = ('default' in IconSdkRaw.default ? IconSdkRaw.default : IconSdkRaw) as typeof IconSdkRaw;
-const { IconService: IconServiceConstructor, Builder: IconBuilder, Converter: IconConverter } = IconSdk;
-export interface CallData {
-  target: string;
-  method: string;
-  params: string[];
-}
-
-export enum SupportedChainId {
-  MAINNET = 1,
-}
-
-interface ChainInfo {
-  readonly name: string;
-  readonly node: string;
-  readonly APIEndpoint: string;
-  readonly debugAPIEndpoint: string;
-  readonly chainId: number;
-  readonly tracker: string;
-}
-
-export const CHAIN_INFO: { readonly [chainId: number]: ChainInfo } = {
-  [SupportedChainId.MAINNET]: {
-    name: 'ICON Mainnet',
-    node: 'https://ctz.solidwallet.io',
-    APIEndpoint: 'https://ctz.solidwallet.io/api/v3',
-    debugAPIEndpoint: 'https://api.icon.community/api/v3d',
-    chainId: 1,
-    tracker: 'https://tracker.icon.community',
-  },
-};
-
-export class IconXService extends XService {
-  private static instance: IconXService;
-
-  public iconService: IconService;
-
-  private constructor() {
-    super('ICON');
-    this.iconService = new IconServiceConstructor(
-      new IconServiceConstructor.HttpProvider(CHAIN_INFO[SupportedChainId.MAINNET].APIEndpoint),
-    );
-  }
-
-  public static getInstance(): IconXService {
-    if (!IconXService.instance) {
-      IconXService.instance = new IconXService();
-    }
-    return IconXService.instance;
-  }
-
-  private async getAggregateData(requireSuccess: boolean, calls: CallData[]) {
-    const rawTx = new IconBuilder.CallBuilder()
-      // muticall address on mainnet
-      .to('cxa4aa9185e23558cff990f494c1fd2845f6cbf741')
-      .method('tryAggregate')
-      .params({ requireSuccess: IconConverter.toHex(requireSuccess ? 1 : 0), calls })
-      .build();
-
-    try {
-      const result = await this.iconService.call(rawTx).execute();
-      const aggs = result['returnData'];
-
-      const data = aggs.map(agg => {
-        if (agg['success'] === '0x0') {
-          return null;
-        }
-        return agg['returnData'];
-      });
-
-      return data;
-    } catch (err) {
-      console.error(err);
-      return Array(calls.length).fill(null);
-    }
-  }
-
-  async getBalances(address: string | undefined, xTokens: XToken[]) {
-    if (!address) return {};
-
-    const balances = {};
-
-    const nativeXToken = xTokens.find(xToken => isNativeToken(xToken));
-    const nonNativeXTokens = xTokens.filter(xToken => !isNativeToken(xToken));
-
-    if (nativeXToken) {
-      const balance = await this.iconService.getBalance(address).execute();
-      balances[nativeXToken.address] = BigInt(balance.toFixed());
-    }
-
-    const cds: CallData[] = nonNativeXTokens.map(token => {
-      return {
-        target: token.address,
-        method: 'balanceOf',
-        params: [address],
-      };
-    });
-
-    const data: string[] = await this.getAggregateData(
-      false,
-      cds.filter(cd => cd.target.startsWith('cx')),
-    );
-
-    return nonNativeXTokens.reduce((agg, token, idx) => {
-      const balance = data[idx];
-      balances[token.address] = BigInt(balance);
-
-      return agg;
-    }, balances);
-  }
-}

package/src/xchains/icon/actions.ts

@@ -1,28 +0,0 @@
-import { useXWagmiStore } from '@/useXWagmiStore';
-import { ICONexRequestEventType, ICONexResponseEventType, request } from './iconex';
-
-export const reconnectIcon = async () => {
-  const iconConnection = useXWagmiStore.getState().xConnections.ICON;
-  if (!iconConnection) return;
-
-  const recentXConnectorId = iconConnection.xConnectorId;
-
-  const detail = await request({
-    type: ICONexRequestEventType.REQUEST_ADDRESS,
-  });
-
-  if (detail?.type === ICONexResponseEventType.RESPONSE_ADDRESS) {
-    useXWagmiStore.setState({
-      xConnections: {
-        ...useXWagmiStore.getState().xConnections,
-        ICON: {
-          xAccount: {
-            address: detail?.payload,
-            xChainType: 'ICON',
-          },
-          xConnectorId: recentXConnectorId,
-        },
-      },
-    });
-  }
-};

package/src/xchains/icon/iconex/index.tsx

@@ -1,46 +0,0 @@
-const ICONEX_RELAY_RESPONSE = 'ICONEX_RELAY_RESPONSE';
-const ICONEX_RELAY_REQUEST = 'ICONEX_RELAY_REQUEST';
-
-export enum ICONexRequestEventType {
-  REQUEST_HAS_ACCOUNT = 'REQUEST_HAS_ACCOUNT',
-  REQUEST_HAS_ADDRESS = 'REQUEST_HAS_ADDRESS',
-  REQUEST_ADDRESS = 'REQUEST_ADDRESS',
-  REQUEST_JSON = 'REQUEST_JSON',
-  REQUEST_SIGNING = 'REQUEST_SIGNING',
-}
-
-export enum ICONexResponseEventType {
-  RESPONSE_HAS_ACCOUNT = 'RESPONSE_HAS_ACCOUNT',
-  RESPONSE_HAS_ADDRESS = 'RESPONSE_HAS_ADDRESS',
-  RESPONSE_ADDRESS = 'RESPONSE_ADDRESS',
-  RESPONSE_JSON = 'RESPONSE_JSON',
-  RESPONSE_SIGNING = 'RESPONSE_SIGNING',
-}
-
-export interface ICONexRequestEvent {
-  type: ICONexRequestEventType;
-  payload?: any;
-}
-
-export interface ICONexResponseEvent {
-  type: ICONexResponseEventType;
-  payload?: any;
-}
-
-export type ICONexEvent = ICONexRequestEvent | ICONexResponseEvent;
-
-export const request = (event: ICONexRequestEvent): Promise<ICONexResponseEvent> => {
-  return new Promise((resolve, reject) => {
-    const handler = evt => {
-      window.removeEventListener(ICONEX_RELAY_RESPONSE, handler);
-      resolve(evt.detail);
-    };
-
-    window.addEventListener(ICONEX_RELAY_RESPONSE, handler);
-    window.dispatchEvent(
-      new CustomEvent(ICONEX_RELAY_REQUEST, {
-        detail: event,
-      }),
-    );
-  });
-};

package/src/xchains/icon/index.ts

@@ -1,2 +0,0 @@
-export { IconXService } from './IconXService';
-export { IconHanaXConnector } from './IconHanaXConnector';

package/src/xchains/injective/InjectiveXConnector.ts

@@ -1,60 +0,0 @@
-import type { XAccount } from '@/types';
-import { XConnector } from '@/core';
-import { getInjectiveAddress } from '@injectivelabs/sdk-ts';
-import { type Wallet, isEvmBrowserWallet, isCosmosBrowserWallet } from '@injectivelabs/wallet-base';
-import { isCosmosWalletInstalled } from '@injectivelabs/wallet-cosmos';
-import { InjectiveXService } from './InjectiveXService';
-
-const WALLET_ICONS: Partial<Record<Wallet, string>> = {
-  metamask: 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/metamask.svg',
-  keplr: 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/keplr.svg',
-  leap: 'https://assets.leapwallet.io/logos/leap-cosmos-logo.svg',
-  rabby: 'https://raw.githubusercontent.com/RabbyHub/logo/master/symbol.svg',
-  phantom: 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/phantom.svg',
-  'okx-wallet': 'https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png',
-  'trust-wallet': 'https://trustwallet.com/assets/images/media/assets/twLogo.svg',
-};
-
-export class InjectiveXConnector extends XConnector {
-  private wallet: Wallet;
-
-  constructor(name: string, wallet: Wallet) {
-    super('INJECTIVE', name, wallet);
-    this.wallet = wallet;
-  }
-
-  getXService(): InjectiveXService {
-    return InjectiveXService.getInstance();
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    if (isCosmosBrowserWallet(this.wallet) && !isCosmosWalletInstalled(this.wallet)) {
-      return undefined;
-    }
-
-    const walletStrategy = this.getXService().walletStrategy;
-    await walletStrategy.setWallet(this.wallet);
-    const addresses = await walletStrategy.getAddresses();
-
-    if (!addresses?.length) return undefined;
-
-    const address = isEvmBrowserWallet(this.wallet) ? getInjectiveAddress(addresses[0]) : addresses[0];
-
-    return {
-      address,
-      xChainType: this.xChainType,
-    };
-  }
-
-  async disconnect(): Promise<void> {
-    if (isEvmBrowserWallet(this.wallet)) {
-      const walletStrategy = this.getXService().walletStrategy;
-      await walletStrategy.setWallet(this.wallet);
-      await walletStrategy.disconnect();
-    }
-  }
-
-  public get icon(): string | undefined {
-    return WALLET_ICONS[this.wallet];
-  }
-}

package/src/xchains/injective/InjectiveXService.ts

@@ -1,62 +0,0 @@
-import { XService } from '@/core/XService';
-import { Network, getNetworkEndpoints } from '@injectivelabs/networks';
-import { ChainGrpcWasmApi, IndexerGrpcAccountPortfolioApi } from '@injectivelabs/sdk-ts';
-import { ChainId as InjectiveChainId } from '@injectivelabs/ts-types';
-import { MsgBroadcaster } from '@injectivelabs/wallet-core';
-import type { XToken } from '@sodax/types';
-import { mainnet } from 'wagmi/chains';
-import { WalletStrategy } from '@injectivelabs/wallet-strategy';
-
-export class InjectiveXService extends XService {
-  private static instance: InjectiveXService;
-
-  public walletStrategy: WalletStrategy;
-  public indexerGrpcAccountPortfolioApi: IndexerGrpcAccountPortfolioApi;
-  public chainGrpcWasmApi: ChainGrpcWasmApi;
-  public msgBroadcaster: MsgBroadcaster;
-
-  private constructor() {
-    super('INJECTIVE');
-
-    const endpoints = getNetworkEndpoints(Network.Mainnet);
-
-    this.walletStrategy = new WalletStrategy({
-      chainId: InjectiveChainId.Mainnet,
-      strategies: {},
-      evmOptions: {
-        evmChainId: mainnet.id,
-        rpcUrl: mainnet.rpcUrls.default.http[0],
-      },
-    });
-
-    this.indexerGrpcAccountPortfolioApi = new IndexerGrpcAccountPortfolioApi(endpoints.indexer);
-    this.chainGrpcWasmApi = new ChainGrpcWasmApi(endpoints.grpc);
-    this.msgBroadcaster = new MsgBroadcaster({
-      walletStrategy: this.walletStrategy,
-      network: Network.Mainnet,
-      endpoints,
-    });
-  }
-
-  public static getInstance(): InjectiveXService {
-    if (!InjectiveXService.instance) {
-      InjectiveXService.instance = new InjectiveXService();
-    }
-    return InjectiveXService.instance;
-  }
-
-  async getBalance(address: string | undefined, xToken: XToken) {
-    if (!address) return 0n;
-
-    const portfolio = await this.indexerGrpcAccountPortfolioApi.fetchAccountPortfolioBalances(address);
-
-    const xTokenAddress = xToken.address;
-
-    const balance = portfolio.bankBalancesList.find(_balance => _balance.denom === xTokenAddress);
-    if (balance) {
-      return BigInt(balance.amount);
-    }
-
-    return 0n;
-  }
-}

package/src/xchains/injective/actions.ts

@@ -1,32 +0,0 @@
-import { useXWagmiStore } from '@/useXWagmiStore';
-import { InjectiveXService } from './InjectiveXService';
-import { isEvmBrowserWallet } from '@injectivelabs/wallet-base';
-import { getInjectiveAddress } from '@injectivelabs/sdk-ts';
-import type { Wallet } from '@injectivelabs/wallet-base';
-
-export const reconnectInjective = async () => {
-  const injectiveConnection = useXWagmiStore.getState().xConnections.INJECTIVE;
-  if (!injectiveConnection) return;
-
-  const recentXConnectorId = injectiveConnection.xConnectorId;
-  const walletStrategy = InjectiveXService.getInstance().walletStrategy;
-  await walletStrategy.setWallet(recentXConnectorId as Wallet);
-  const addresses = await walletStrategy.getAddresses();
-
-  const address = isEvmBrowserWallet(recentXConnectorId as Wallet)
-    ? getInjectiveAddress(addresses?.[0])
-    : addresses?.[0];
-
-  useXWagmiStore.setState({
-    xConnections: {
-      ...useXWagmiStore.getState().xConnections,
-      INJECTIVE: {
-        xAccount: {
-          address,
-          xChainType: 'INJECTIVE',
-        },
-        xConnectorId: recentXConnectorId,
-      },
-    },
-  });
-};

package/src/xchains/injective/index.ts

@@ -1,2 +0,0 @@
-export { InjectiveXService } from './InjectiveXService';
-export { InjectiveXConnector } from './InjectiveXConnector';

package/src/xchains/near/NearXConnector.ts

@@ -1,42 +0,0 @@
-import type { XAccount } from '@/types';
-
-import { XConnector } from '@/core';
-import type { NearWalletBase } from '@hot-labs/near-connect';
-import { NearXService } from './NearXService';
-
-export class NearXConnector extends XConnector {
-  _wallet: NearWalletBase;
-
-  constructor(wallet: NearWalletBase) {
-    super('NEAR', wallet.manifest.name, wallet.manifest.id);
-    this._wallet = wallet;
-  }
-
-  getXService(): NearXService {
-    return NearXService.getInstance();
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    const walletSelector = this.getXService().walletSelector;
-    const wallet = await walletSelector.connect({ walletId: this._wallet.manifest.id });
-    const accounts = await wallet.getAccounts();
-
-    if (accounts.length === 0 || accounts[0] === undefined) {
-      return undefined;
-    }
-
-    return {
-      address: accounts[0].accountId,
-      xChainType: this.xChainType,
-    };
-  }
-
-  async disconnect(): Promise<void> {
-    const walletSelector = this.getXService().walletSelector;
-    await walletSelector.disconnect(this._wallet);
-  }
-
-  public get icon() {
-    return this._wallet.manifest.icon;
-  }
-}

package/src/xchains/near/NearXService.ts

@@ -1,46 +0,0 @@
-import { XService } from '@/core/XService';
-import type { XToken } from '@sodax/types';
-import { NearConnector } from '@hot-labs/near-connect';
-import { JsonRpcProvider } from 'near-api-js';
-
-export class NearXService extends XService {
-  private static instance: NearXService;
-
-  public walletSelector: NearConnector;
-
-  private constructor() {
-    super('NEAR');
-
-    this.walletSelector = new NearConnector({
-      network: 'mainnet',
-      logger: console,
-      autoConnect: true,
-      excludedWallets: ['okx-wallet'],
-    });
-  }
-
-  public static getInstance(): NearXService {
-    if (!NearXService.instance) {
-      NearXService.instance = new NearXService();
-    }
-    return NearXService.instance;
-  }
-
-  async getBalance(address: string | undefined, xToken: XToken): Promise<bigint> {
-    const url = 'https://1rpc.io/near';
-    // reference: https://near.github.io/near-api-js/classes/_near-js_providers.json-rpc-provider.JsonRpcProvider.html
-    const provider = new JsonRpcProvider({ url });
-
-    // get native balance
-    if (xToken.symbol === 'NEAR') {
-      const account = await provider.viewAccount({ accountId: address ?? '' });
-      return BigInt(account.amount);
-    }
-
-    // Near Fungible Token Standard(https://github.com/near/NEPs/blob/master/neps/nep-0141.md)
-    // get balance of the token
-
-    const res = await provider.callFunction<number>({ contractId: xToken.address, method: 'ft_balance_of', args: { account_id: address } });
-    return BigInt(res ?? 0);
-  }
-}

package/src/xchains/near/useNearXConnectors.ts

@@ -1,23 +0,0 @@
-import { useXService } from '@/hooks';
-import { type UseQueryResult, useQuery } from '@tanstack/react-query';
-
-import { NearXConnector } from './NearXConnector';
-import type { NearXService } from './NearXService';
-
-export const useNearXConnectors = (): UseQueryResult<NearXConnector[] | undefined, Error | null> => {
-  const xService = useXService('NEAR') as NearXService;
-
-  return useQuery({
-    queryKey: ['near-wallets'],
-    queryFn: async () => {
-      if (!xService) {
-        return [];
-      }
-
-      await xService.walletSelector.whenManifestLoaded;
-      const wallets = xService.walletSelector.availableWallets;
-
-      return wallets.map(wallet => new NearXConnector(wallet));
-    },
-  });
-};

package/src/xchains/solana/SolanaXConnector.ts

@@ -1,26 +0,0 @@
-import type { XAccount } from '@/types';
-
-import { XConnector } from '@/core';
-import { SolanaXService } from './SolanaXService';
-
-export class SolanaXConnector extends XConnector {
-  wallet: any;
-  constructor(wallet: any) {
-    super('SOLANA', wallet?.adapter.name, wallet?.adapter.name);
-    this.wallet = wallet;
-  }
-
-  getXService(): SolanaXService {
-    return SolanaXService.getInstance();
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    return;
-  }
-
-  async disconnect(): Promise<void> {}
-
-  public get icon() {
-    return this.wallet?.adapter.icon;
-  }
-}

package/src/xchains/solana/SolanaXService.ts

@@ -1,46 +0,0 @@
-import { XService } from '@/core/XService';
-import { isNativeToken } from '@/utils';
-import type { XToken } from '@sodax/types';
-import { type Connection, PublicKey } from '@solana/web3.js';
-import { getAccount, getAssociatedTokenAddressSync } from '@solana/spl-token';
-import type { WalletContextState } from '@solana/wallet-adapter-react';
-
-export class SolanaXService extends XService {
-  private static instance: SolanaXService;
-
-  public connection: Connection | undefined;
-  public wallet: WalletContextState | undefined;
-
-  private constructor() {
-    super('SOLANA');
-  }
-
-  public static getInstance(): SolanaXService {
-    if (!SolanaXService.instance) {
-      SolanaXService.instance = new SolanaXService();
-    }
-    return SolanaXService.instance;
-  }
-
-  async getBalance(address: string | undefined, xToken: XToken): Promise<bigint> {
-    if (!address) return BigInt(0);
-
-    const connection = this.connection;
-    if (!connection) {
-      return BigInt(0);
-    }
-
-    try {
-      if (isNativeToken(xToken)) {
-        const newBalance = await connection.getBalance(new PublicKey(address));
-        return BigInt(newBalance);
-      }
-
-      const tokenAccountPubkey = getAssociatedTokenAddressSync(new PublicKey(xToken.address), new PublicKey(address));
-      const tokenAccount = await getAccount(connection, tokenAccountPubkey);
-      return BigInt(tokenAccount.amount);
-    } catch {
-      return BigInt(0);
-    }
-  }
-}

package/src/xchains/solana/index.ts

@@ -1,2 +0,0 @@
-export { SolanaXService } from './SolanaXService';
-export { SolanaXConnector } from './SolanaXConnector';

package/src/xchains/stacks/StacksXConnector.ts

@@ -1,63 +0,0 @@
-import type { XAccount } from '@/types';
-import { XConnector } from '@/core';
-import type { StacksProvider } from '@stacks/connect';
-import { request, disconnect } from '@stacks/connect';
-
-export interface StacksProviderConfig {
-  /** The provider ID matching the window path, e.g. 'LeatherProvider' or 'XverseProviders.BitcoinProvider' */
-  id: string;
-  name: string;
-  icon: string;
-  installUrl?: string;
-}
-
-/** Resolves a provider from `window` by dot-separated ID, matching @stacks/connect-ui's getProviderFromId */
-function getProviderFromId(id: string): StacksProvider | undefined {
-  // biome-ignore lint/suspicious/noExplicitAny: window property traversal requires any
-  return id.split('.').reduce<any>((acc, part) => acc?.[part], window) as StacksProvider | undefined;
-}
-
-export class StacksXConnector extends XConnector {
-  private readonly config: StacksProviderConfig;
-
-  constructor(config: StacksProviderConfig) {
-    super('STACKS', config.name, config.id);
-    this.config = config;
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    const provider = this.getProvider();
-
-    if (!provider) {
-      if (this.config.installUrl) {
-        window.open(this.config.installUrl, '_blank');
-      }
-      return undefined;
-    }
-
-    const response = await request({ provider }, 'stx_getAddresses');
-    // @ts-ignore
-    const stxAddress = response.addresses.find(a => a.purpose === 'stacks');
-
-    if (!stxAddress) {
-      return undefined;
-    }
-
-    return {
-      address: stxAddress.address,
-      xChainType: this.xChainType,
-    };
-  }
-
-  async disconnect(): Promise<void> {
-    disconnect();
-  }
-
-  public get icon(): string {
-    return this.config.icon;
-  }
-
-  public getProvider(): StacksProvider | undefined {
-    return getProviderFromId(this.config.id);
-  }
-}

package/src/xchains/stacks/StacksXService.ts

@@ -1,59 +0,0 @@
-import { XService } from '@/core/XService';
-import type { XToken } from '@sodax/types';
-import { fetchCallReadOnlyFunction, Cl, type UIntCV, type ResponseOkCV } from '@stacks/transactions';
-import { networkFrom, type StacksNetwork } from '@stacks/network';
-
-export class StacksXService extends XService {
-  private static instance: StacksXService;
-
-  public network: StacksNetwork | undefined;
-
-  private constructor() {
-    super('STACKS');
-    this.network = networkFrom('mainnet');
-  }
-
-  public static getInstance(): StacksXService {
-    if (!StacksXService.instance) {
-      StacksXService.instance = new StacksXService();
-    }
-    return StacksXService.instance;
-  }
-
-  async getBalance(address: string | undefined, xToken: XToken): Promise<bigint> {
-    if (!address) return 0n;
-
-    // native STX balance
-    if (xToken.symbol === 'STX') {
-      const url = `${this.network?.client.baseUrl}/extended/v1/address/${address}/balances`;
-      try {
-        const response = await fetch(url);
-        if (!response.ok) {
-          throw new Error(`Error fetching data: ${response.statusText}`);
-        }
-        const data = await response.json();
-        return BigInt(data.stx.balance);
-      } catch (error) {
-        console.error('Error fetching STX balance:', error);
-        return 0n;
-      }
-    }
-
-    // SIP-010 fungible token balance via read-only contract call
-    const [contractAddress, contractName] = xToken.address.split('.');
-    try {
-      const result = (await fetchCallReadOnlyFunction({
-        contractAddress,
-        contractName,
-        functionName: 'get-balance',
-        functionArgs: [Cl.principal(address)],
-        network: this.network,
-        senderAddress: address,
-      })) as ResponseOkCV<UIntCV>;
-      return result.value.value as bigint;
-    } catch (error) {
-      console.error('Error fetching token balance:', error);
-      return 0n;
-    }
-  }
-}