@sodax/wallet-sdk-react 0.0.1-rc.2

package/src/xchains/icon/IconXService.ts

@@ -0,0 +1,115 @@
+import { XService } from '@/core/XService';
+import type { IconService } from 'icon-sdk-js';
+import { IconService as IconServiceConstructor, Builder as IconBuilder, Converter as IconConverter } from 'icon-sdk-js';
+import type { ChainId, XToken } from '@sodax/types';
+import { isNativeToken } from '@/utils';
+
+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[], xChainId: ChainId) {
+    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/iconex/index.tsx

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

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

package/src/xchains/injective/InjectiveKelprXConnector.ts

@@ -0,0 +1,37 @@
+import type { XAccount } from '@/types';
+
+import { XConnector } from '@/core';
+import { Wallet } from '@injectivelabs/wallet-base';
+import { isCosmosWalletInstalled } from '@injectivelabs/wallet-cosmos';
+import { InjectiveXService } from './InjectiveXService';
+
+export class InjectiveKelprXConnector extends XConnector {
+  constructor() {
+    super('INJECTIVE', 'Keplr', 'keplr');
+  }
+
+  getXService(): InjectiveXService {
+    return InjectiveXService.getInstance();
+  }
+
+  async connect(): Promise<XAccount | undefined> {
+    if (!isCosmosWalletInstalled(Wallet.Keplr)) {
+      window.open('https://chrome.google.com/webstore/detail/keplr/dmkamcknogkgcdfhhbddcghachkejeap?hl=en', '_blank');
+      return;
+    }
+
+    this.getXService().walletStrategy.setWallet(Wallet.Keplr);
+    const addresses = await this.getXService().walletStrategy.getAddresses();
+
+    return {
+      address: addresses?.[0],
+      xChainType: this.xChainType,
+    };
+  }
+
+  async disconnect(): Promise<void> {}
+
+  public get icon() {
+    return 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/keplr.svg';
+  }
+}

package/src/xchains/injective/InjectiveMetamaskXConnector.ts

@@ -0,0 +1,40 @@
+import type { XAccount } from '@/types';
+
+import { XConnector } from '@/core';
+import { getInjectiveAddress } from '@injectivelabs/sdk-ts';
+import { isEvmBrowserWallet, Wallet } from '@injectivelabs/wallet-base';
+import { InjectiveXService } from './InjectiveXService';
+
+export class InjectiveMetamaskXConnector extends XConnector {
+  constructor() {
+    super('INJECTIVE', 'MetaMask', 'metamask');
+  }
+
+  getXService(): InjectiveXService {
+    return InjectiveXService.getInstance();
+  }
+
+  async connect(): Promise<XAccount | undefined> {
+    if (!isEvmBrowserWallet(Wallet.Metamask)) {
+      window.open('https://chromewebstore.google.com/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn?hl=en', '_blank');
+      return;
+    }
+
+    this.getXService().walletStrategy.setWallet(Wallet.Metamask);
+    const addresses = await this.getXService().walletStrategy.getAddresses();
+    const injectiveAddresses = addresses.map(getInjectiveAddress);
+
+    return {
+      address: injectiveAddresses?.[0],
+      xChainType: this.xChainType,
+    };
+  }
+
+  async disconnect(): Promise<void> {
+    await this.getXService().walletStrategy.disconnect();
+  }
+
+  public get icon() {
+    return 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/metamask.svg';
+  }
+}

package/src/xchains/injective/InjectiveXService.ts

@@ -0,0 +1,71 @@
+import { XService } from '@/core/XService';
+import { Network, getNetworkEndpoints } from '@injectivelabs/networks';
+import { ChainGrpcWasmApi, IndexerGrpcAccountPortfolioApi } from '@injectivelabs/sdk-ts';
+import { ChainId as InjectiveChainId, EvmChainId } from '@injectivelabs/ts-types';
+import { EvmWalletStrategy } from '@injectivelabs/wallet-evm';
+import { MsgBroadcaster, BaseWalletStrategy } from '@injectivelabs/wallet-core';
+import { Wallet } from '@injectivelabs/wallet-base';
+// import { CosmosWalletStrategy } from '@injectivelabs/wallet-cosmos';
+import type { XToken } from '@sodax/types';
+import { mainnet } from 'wagmi/chains';
+
+export class InjectiveXService extends XService {
+  private static instance: InjectiveXService;
+
+  public walletStrategy: BaseWalletStrategy;
+  public indexerGrpcAccountPortfolioApi: IndexerGrpcAccountPortfolioApi;
+  public chainGrpcWasmApi: ChainGrpcWasmApi;
+  public msgBroadcaster: MsgBroadcaster;
+
+  private constructor() {
+    super('INJECTIVE');
+
+    const endpoints = getNetworkEndpoints(Network.Mainnet);
+    this.walletStrategy = new BaseWalletStrategy({
+      chainId: InjectiveChainId.Mainnet,
+      strategies: {
+        [Wallet.Metamask]: new EvmWalletStrategy({
+          chainId: InjectiveChainId.Mainnet,
+          wallet: Wallet.Metamask,
+          evmOptions: {
+            evmChainId: EvmChainId.Mainnet,
+            rpcUrl: mainnet.rpcUrls.default.http[0],
+          },
+        }),
+        // [Wallet.Keplr]: new CosmosWalletStrategy({
+        //   chainId: InjectiveChainId.Mainnet,
+        //   wallet: Wallet.Keplr,
+        // }),
+      },
+    });
+    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/index.ts

@@ -0,0 +1,4 @@
+export { InjectiveXService } from './InjectiveXService';
+export { InjectiveKelprXConnector } from './InjectiveKelprXConnector';
+export { InjectiveMetamaskXConnector } from './InjectiveMetamaskXConnector';
+export * from './utils';

package/src/xchains/injective/utils.ts

@@ -0,0 +1,17 @@
+export const switchEthereumChain = async chainId => {
+  const metamaskProvider = (window as any).ethereum as any;
+
+  await Promise.race([
+    metamaskProvider.request({
+      method: 'wallet_switchEthereumChain',
+      params: [{ chainId: `0x${chainId}` }],
+    }),
+    new Promise<void>(resolve =>
+      metamaskProvider.on('change', ({ chain }: any) => {
+        if (chain?.id === chainId) {
+          resolve();
+        }
+      }),
+    ),
+  ]);
+};

package/src/xchains/solana/SolanaXConnector.ts

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

@@ -0,0 +1,50 @@
+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 { AnchorProvider } from '@coral-xyz/anchor';
+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;
+  public provider: AnchorProvider | 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) {
+      throw new Error('Connection is not initialized');
+    }
+
+    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 (e) {
+      console.log('error', e);
+    }
+
+    return BigInt(0);
+  }
+}

package/src/xchains/solana/hooks/useAnchorProvider.tsx

@@ -0,0 +1,9 @@
+import { AnchorProvider } from '@coral-xyz/anchor';
+import { type AnchorWallet, useConnection, useWallet } from '@solana/wallet-adapter-react';
+
+export function useAnchorProvider() {
+  const { connection } = useConnection();
+  const wallet = useWallet();
+
+  return new AnchorProvider(connection, wallet as AnchorWallet, { commitment: 'confirmed' });
+}

package/src/xchains/solana/index.ts

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

package/src/xchains/stellar/CustomSorobanServer.ts

@@ -0,0 +1,93 @@
+import {
+  type FeeBumpTransaction,
+  type Memo,
+  type MemoType,
+  type Operation,
+  SorobanRpc,
+  type Transaction,
+} from '@stellar/stellar-sdk';
+
+class CustomSorobanServer extends SorobanRpc.Server {
+  private readonly customHeaders: Record<string, string>;
+
+  constructor(serverUrl: string, customHeaders: Record<string, string>) {
+    super(serverUrl, {
+      allowHttp: true,
+    });
+    this.customHeaders = customHeaders;
+  }
+
+  async simulateTransaction(
+    tx: Transaction<Memo<MemoType>, Operation[]>,
+  ): Promise<SorobanRpc.Api.SimulateTransactionResponse> {
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.customHeaders,
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'simulateTransaction',
+        params: {
+          transaction: tx.toXDR(),
+        },
+      }),
+    };
+
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error simulating TX! status: ${response.status}`);
+    }
+    return response.json().then(json => json.result);
+  }
+
+  async sendTransaction(tx: Transaction | FeeBumpTransaction): Promise<SorobanRpc.Api.SendTransactionResponse> {
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.customHeaders,
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'sendTransaction',
+        params: {
+          transaction: tx.toXDR(),
+        },
+      }),
+    };
+
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error submitting TX! status: ${response.status}`);
+    }
+    return response.json().then(json => json.result);
+  }
+
+  async getTransaction(hash: string): Promise<SorobanRpc.Api.GetTransactionResponse> {
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.customHeaders,
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'getTransaction',
+        params: { hash },
+      }),
+    };
+
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error getting TX! status: ${response.status}`);
+    }
+    return response.json().then(json => json.result);
+  }
+}
+
+export default CustomSorobanServer;

package/src/xchains/stellar/StellarWalletsKitXConnector.ts

@@ -0,0 +1,45 @@
+import type { XAccount } from '@/types';
+
+import { XConnector } from '@/core';
+import { StellarXService } from './StellarXService';
+import type { StellarWalletType } from './useStellarXConnectors';
+
+export class StellarWalletsKitXConnector extends XConnector {
+  _wallet: StellarWalletType;
+
+  constructor(wallet: StellarWalletType) {
+    super('STELLAR', wallet.name, wallet.id);
+    this._wallet = wallet;
+  }
+
+  getXService(): StellarXService {
+    return StellarXService.getInstance();
+  }
+
+  async connect(): Promise<XAccount | undefined> {
+    const kit = this.getXService().walletsKit;
+
+    if (!this._wallet) {
+      return;
+    }
+
+    if (!this._wallet.isAvailable && this._wallet.url) {
+      window.open(this._wallet.url, '_blank');
+      return;
+    }
+
+    kit.setWallet(this._wallet.id);
+    const { address } = await kit.getAddress();
+
+    return {
+      address: address,
+      xChainType: this.xChainType,
+    };
+  }
+
+  async disconnect(): Promise<void> {}
+
+  public get icon() {
+    return this._wallet.icon;
+  }
+}

package/src/xchains/stellar/StellarXService.ts

@@ -0,0 +1,61 @@
+import { XService } from '@/core/XService';
+import { FREIGHTER_ID, StellarWalletsKit, WalletNetwork, allowAllModules } from '@creit.tech/stellar-wallets-kit';
+import * as StellarSdk from '@stellar/stellar-sdk';
+import CustomSorobanServer from './CustomSorobanServer';
+import { getTokenBalance } from './utils';
+import type { XToken } from '@sodax/types';
+
+export class StellarXService extends XService {
+  private static instance: StellarXService;
+
+  public walletsKit: StellarWalletsKit;
+  public server: StellarSdk.Horizon.Server;
+  public sorobanServer: CustomSorobanServer;
+
+  private constructor() {
+    super('STELLAR');
+
+    this.walletsKit = new StellarWalletsKit({
+      network: WalletNetwork.PUBLIC,
+      selectedWalletId: FREIGHTER_ID,
+      modules: allowAllModules(),
+    });
+
+    this.server = new StellarSdk.Horizon.Server('https://horizon.stellar.org', { allowHttp: true });
+    this.sorobanServer = new CustomSorobanServer('https://rpc.ankr.com/stellar_soroban', {});
+  }
+
+  public static getInstance(): StellarXService {
+    if (!StellarXService.instance) {
+      StellarXService.instance = new StellarXService();
+    }
+    return StellarXService.instance;
+  }
+
+  async getBalance(address: string | undefined, xToken: XToken): Promise<bigint> {
+    if (!address) return BigInt(0);
+
+    const stellarAccount = await this.server.loadAccount(address);
+
+    if (xToken.symbol === 'XLM') {
+      const xlmBalance = stellarAccount.balances.find(balance => balance.asset_type === 'native');
+      if (xlmBalance) {
+        return BigInt(xlmBalance.balance.replace('.', ''));
+      }
+    } else {
+      try {
+        const txBuilder = new StellarSdk.TransactionBuilder(stellarAccount, {
+          fee: StellarSdk.BASE_FEE,
+          networkPassphrase: StellarSdk.Networks.PUBLIC,
+        });
+
+        const balance = await getTokenBalance(address, xToken.address, txBuilder, this.sorobanServer);
+        return balance;
+      } catch (e) {
+        console.error(`Error while fetching token on Stellar: ${xToken.symbol}, Error: ${e}`);
+      }
+    }
+
+    return BigInt(0);
+  }
+}

package/src/xchains/stellar/index.tsx

@@ -0,0 +1,2 @@
+export { StellarXService } from './StellarXService';
+export { StellarWalletsKitXConnector } from './StellarWalletsKitXConnector';

package/src/xchains/stellar/useStellarXConnectors.ts

@@ -0,0 +1,30 @@
+import { useXService } from '@/hooks';
+import { type UseQueryResult, useQuery } from '@tanstack/react-query';
+
+import { StellarWalletsKitXConnector, type StellarXService } from '.';
+
+export type StellarWalletType = {
+  icon: string;
+  id: string;
+  isAvailable: boolean;
+  name: string;
+  type: string;
+  url: string;
+};
+
+export const useStellarXConnectors = (): UseQueryResult<StellarWalletsKitXConnector[] | undefined, Error | null> => {
+  const xService = useXService('STELLAR') as StellarXService;
+
+  return useQuery({
+    queryKey: ['stellar-wallets', xService],
+    queryFn: async () => {
+      if (!xService) {
+        return [];
+      }
+
+      const wallets: StellarWalletType[] = await xService.walletsKit.getSupportedWallets();
+
+      return wallets.filter(wallet => wallet.isAvailable).map(wallet => new StellarWalletsKitXConnector(wallet));
+    },
+  });
+};