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

package/src/xchains/bitcoin/UnisatXConnector.ts

@@ -1,117 +0,0 @@
-import type { XAccount } from '@/types';
-import { detectBitcoinAddressType, type IBitcoinWalletProvider, type AddressType } from '@sodax/types';
-import { BitcoinXConnector } from './BitcoinXConnector';
-
-// Minimal Unisat window API types
-interface UnisatWallet {
-  getAccounts(): Promise<string[]>;
-  getPublicKey(): Promise<string>;
-  signPsbt(psbtHex: string, options?: { autoFinalized?: boolean }): Promise<string>;
-  signMessage(message: string, type?: 'bip322-simple' | 'ecdsa'): Promise<string>;
-  requestAccounts(): Promise<string[]>;
-  sendBitcoin(address: string, satoshis: number): Promise<string>;
-}
-
-declare global {
-  interface Window {
-    unisat?: UnisatWallet;
-  }
-}
-
-class UnisatWalletProvider implements IBitcoinWalletProvider {
-  private unisat: UnisatWallet;
-  private cachedAddress: string;
-
-  constructor(unisat: UnisatWallet, address: string) {
-    this.unisat = unisat;
-    this.cachedAddress = address;
-  }
-
-  async getWalletAddress(): Promise<string> {
-    try {
-      const accounts = await this.unisat.getAccounts();
-      if (accounts[0]) this.cachedAddress = accounts[0];
-    } catch {
-      // wallet locked — fall through to cached address
-    }
-    return this.cachedAddress;
-  }
-
-  async getPublicKey(): Promise<string> {
-    return this.unisat.getPublicKey();
-  }
-
-  async getAddressType(_address: string): Promise<AddressType> {
-    const address = await this.getWalletAddress();
-    return detectBitcoinAddressType(address);
-  }
-
-  async signTransaction(psbtBase64: string, finalize = false): Promise<string> {
-    // Convert base64 → hex for Unisat, then back
-    const psbtHex = Buffer.from(psbtBase64, 'base64').toString('hex');
-    const signedHex = await this.unisat.signPsbt(psbtHex, { autoFinalized: finalize });
-    // Return as hex (BTCWalletProvider.signTransaction expects this)
-    return signedHex;
-  }
-
-  async signEcdsaMessage(message: string): Promise<string> {
-    return this.unisat.signMessage(message, 'ecdsa');
-  }
-
-  async signBip322Message(message: string): Promise<string> {
-    return this.unisat.signMessage(message, 'bip322-simple');
-  }
-
-  async sendBitcoin(toAddress: string, satoshis: bigint): Promise<string> {
-    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
-    }
-    return this.unisat.sendBitcoin(toAddress, Number(satoshis));
-  }
-}
-
-export class UnisatXConnector extends BitcoinXConnector {
-  private walletProvider: UnisatWalletProvider | undefined;
-
-  constructor() {
-    super('Unisat', 'unisat');
-  }
-
-  public static isAvailable(): boolean {
-    return typeof window !== 'undefined' && !!window.unisat;
-  }
-
-  public get icon(): string {
-    return 'https://avatars.githubusercontent.com/u/125119198?s=200&v=4';
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    if (!window.unisat) {
-      throw new Error('Unisat wallet is not installed');
-    }
-
-    const accounts = await window.unisat.requestAccounts();
-    const address = accounts[0];
-    if (!address) return undefined;
-
-    this.walletProvider = new UnisatWalletProvider(window.unisat, address);
-
-    return {
-      address,
-      xChainType: 'BITCOIN',
-    };
-  }
-
-  async disconnect(): Promise<void> {
-    this.walletProvider = undefined;
-  }
-
-  getWalletProvider(): IBitcoinWalletProvider | undefined {
-    return this.walletProvider;
-  }
-
-  recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined {
-    if (!window.unisat || !xAccount.address) return undefined;
-    return new UnisatWalletProvider(window.unisat, xAccount.address);
-  }
-}

package/src/xchains/bitcoin/XverseXConnector.ts

@@ -1,232 +0,0 @@
-import type { XAccount } from '@/types';
-import { detectBitcoinAddressType, type IBitcoinWalletProvider, type AddressType, type BtcWalletAddressType } from '@sodax/types';
-import { AddressPurpose, MessageSigningProtocols } from 'sats-connect';
-import { BitcoinXConnector } from './BitcoinXConnector';
-
-// sats-connect types
-interface SignPsbtResult {
-  psbt: string; // base64 signed PSBT
-}
-
-interface GetAccountsResult {
-  address: string;
-  publicKey: string;
-  purpose: string;
-  addressType: string;
-}
-
-interface SignMessageResult {
-  signature: string;
-}
-
-
-class XverseWalletProvider implements IBitcoinWalletProvider {
-  private address: string;
-  private publicKey: string;
-
-  constructor(address: string, publicKey: string) {
-    this.address = address;
-    this.publicKey = publicKey;
-  }
-
-  async getWalletAddress(): Promise<string> {
-    return this.address;
-  }
-
-  async getPublicKey(): Promise<string> {
-    return this.publicKey;
-  }
-
-  async getAddressType(_address: string): Promise<AddressType> {
-    return detectBitcoinAddressType(this.address);
-  }
-
-  /**
-   * Parse a base64-encoded PSBT to count the number of inputs.
-   * Reads the unsigned transaction from the PSBT global section.
-   */
-  private countPsbtInputs(psbtBase64: string): number {
-    const data = Buffer.from(psbtBase64, 'base64');
-    // Skip 5-byte magic (0x70736274FF = "psbt" + separator)
-    let offset = 5;
-
-    // Global section: first key-value pair should be key 0x00 (unsigned tx)
-    const keyLen = data[offset++] ?? 0;
-    if (keyLen !== 1 || data[offset++] !== 0x00) {
-      return 1; // fallback: assume 1 input
-    }
-
-    // Read value length (compact size)
-    const firstByte = data[offset++] ?? 0;
-    if (firstByte === 0xfd) offset += 2;
-    else if (firstByte === 0xfe) offset += 4;
-    else if (firstByte === 0xff) offset += 8;
-    // else firstByte IS the length (< 0xfd), no extra bytes
-
-    // Unsigned tx: skip 4-byte version
-    offset += 4;
-
-    // Read input count (varint)
-    const inputByte = data[offset] ?? 0;
-    if (inputByte < 0xfd) return inputByte;
-    return 1; // fallback for unusual cases
-  }
-
-  async signTransaction(psbtBase64: string, finalize = false): Promise<string> {
-    const { request } = await import('sats-connect');
-
-    const inputCount = this.countPsbtInputs(psbtBase64);
-    const signingIndexes = Array.from({ length: inputCount }, (_, i) => i);
-
-    const response = await request('signPsbt', {
-      psbt: psbtBase64,
-      broadcast: false,
-      signInputs: {
-        [this.address]: signingIndexes,
-      },
-    });
-
-    if (response.status === 'error') {
-      throw new Error(response.error?.message || 'Xverse PSBT signing failed');
-    }
-
-    const result = response.result as SignPsbtResult;
-
-    if (finalize) {
-      // Return hex for broadcast
-      return Buffer.from(result.psbt, 'base64').toString('hex');
-    }
-
-    // Return base64 signed PSBT (partially signed)
-    return result.psbt;
-  }
-
-  async signEcdsaMessage(message: string): Promise<string> {
-    const { request } = await import('sats-connect');
-
-    const response = await request('signMessage', {
-      address: this.address,
-      message,
-      protocol: MessageSigningProtocols.ECDSA,
-    });
-
-    if (response.status === 'error') {
-      throw new Error(response.error?.message || 'Xverse ECDSA signing failed');
-    }
-
-    return (response.result as SignMessageResult).signature;
-  }
-
-  async signBip322Message(message: string): Promise<string> {
-    const { request } = await import('sats-connect');
-
-    const response = await request('signMessage', {
-      address: this.address,
-      message,
-      protocol: MessageSigningProtocols.BIP322,
-    });
-
-    if (response.status === 'error') {
-      throw new Error(response.error?.message || 'Xverse BIP322 signing failed');
-    }
-
-    return (response.result as SignMessageResult).signature;
-  }
-
-  async sendBitcoin(toAddress: string, satoshis: bigint): Promise<string> {
-    const { request } = await import('sats-connect');
-
-    const response = await request('sendTransfer', {
-      recipients: [
-        {
-          address: toAddress,
-          amount: Number(satoshis),
-        },
-      ],
-    });
-
-    if (response.status === 'error') {
-      throw new Error(response.error?.message || 'Xverse sendTransfer failed');
-    }
-
-    return (response.result as { txid: string }).txid;
-  }
-}
-
-const XVERSE_ADDRESS_TYPE_KEY = 'xverse-address-type';
-
-export class XverseXConnector extends BitcoinXConnector {
-  private walletProvider: XverseWalletProvider | undefined;
-
-  /** Address purpose used when connecting. Taproot (Ordinals) by default to match Radfi. */
-  public addressPurpose: AddressPurpose;
-
-  constructor() {
-    super('Xverse', 'xverse');
-    // Restore saved preference, default to Taproot
-    const saved = typeof window !== 'undefined' ? localStorage.getItem(XVERSE_ADDRESS_TYPE_KEY) : null;
-    this.addressPurpose = saved === 'segwit' ? AddressPurpose.Payment : AddressPurpose.Ordinals;
-  }
-
-  /** Set address purpose and persist to localStorage. */
-  public setAddressPurpose(type: BtcWalletAddressType): void {
-    this.addressPurpose = type === 'taproot' ? AddressPurpose.Ordinals : AddressPurpose.Payment;
-    if (typeof window !== 'undefined') {
-      localStorage.setItem(XVERSE_ADDRESS_TYPE_KEY, type);
-    }
-  }
-
-  public static isAvailable(): boolean {
-    return typeof window !== 'undefined' && !!window.BitcoinProvider;
-  }
-
-  public get icon(): string {
-    return 'https://cdn.brandfetch.io/iddzGN5Rcv/w/400/h/400/theme/dark/icon.jpeg?c=1bxid64Mup7aczewSAYMX&t=1771902357797';
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    if (!XverseXConnector.isAvailable()) {
-      throw new Error('Xverse wallet is not installed');
-    }
-
-    const { request } = await import('sats-connect');
-
-    const response = await request('getAccounts', {
-      purposes: [this.addressPurpose],
-      message: 'Connect to Sodax',
-    });
-
-    if (response.status === 'error') {
-      throw new Error(response.error?.message || 'Xverse connection failed');
-    }
-
-    const accounts = response.result as GetAccountsResult[];
-    const paymentAccount = accounts.find(a => a.purpose === this.addressPurpose) || accounts[0];
-
-    if (!paymentAccount) return undefined;
-
-    this.walletProvider = new XverseWalletProvider(
-      paymentAccount.address,
-      paymentAccount.publicKey,
-    );
-
-    return {
-      address: paymentAccount.address,
-      publicKey: paymentAccount.publicKey,
-      xChainType: 'BITCOIN',
-    };
-  }
-
-  async disconnect(): Promise<void> {
-    this.walletProvider = undefined;
-  }
-
-  getWalletProvider(): IBitcoinWalletProvider | undefined {
-    return this.walletProvider;
-  }
-
-  recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined {
-    if (!xAccount.address || !xAccount.publicKey) return undefined;
-    return new XverseWalletProvider(xAccount.address, xAccount.publicKey);
-  }
-}

package/src/xchains/bitcoin/index.ts

@@ -1,7 +0,0 @@
-export { BitcoinXService } from './BitcoinXService';
-export { BitcoinXConnector } from './BitcoinXConnector';
-export { UnisatXConnector } from './UnisatXConnector';
-export { XverseXConnector } from './XverseXConnector';
-export type { BtcWalletAddressType } from '@sodax/types';
-export { OKXXConnector } from './OKXXConnector';
-export { useBitcoinXConnectors } from './useBitcoinXConnectors';

package/src/xchains/bitcoin/useBitcoinXConnectors.ts

@@ -1,14 +0,0 @@
-import { useMemo } from 'react';
-import type { BitcoinXConnector } from './BitcoinXConnector';
-import { useXService } from '../../hooks';
-
-/**
- * Hook to return available Bitcoin wallet connectors from the globally registered xService.
- */
-export function useBitcoinXConnectors(): BitcoinXConnector[] {
-  const xService = useXService('BITCOIN');
-  
-  return useMemo(() => {
-    return (xService?.getXConnectors() || []) as BitcoinXConnector[];
-  }, [xService]);
-}

package/src/xchains/evm/EvmXConnector.ts

@@ -1,27 +0,0 @@
-import { XConnector } from '@/core/XConnector';
-import type { XAccount } from '@/types';
-import type { Connector } from 'wagmi';
-
-export class EvmXConnector extends XConnector {
-  connector: Connector;
-
-  constructor(connector: Connector) {
-    super('EVM', connector.name, connector.id);
-    this.connector = connector;
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    return;
-  }
-
-  async disconnect(): Promise<void> {
-    return;
-  }
-
-  public get id() {
-    return this.connector.id;
-  }
-  public get icon() {
-    return this.connector.icon;
-  }
-}

package/src/xchains/evm/EvmXService.ts

@@ -1,211 +0,0 @@
-import { XService } from '@/core/XService';
-import {
-  ARBITRUM_MAINNET_CHAIN_ID,
-  AVALANCHE_MAINNET_CHAIN_ID,
-  BASE_MAINNET_CHAIN_ID,
-  BSC_MAINNET_CHAIN_ID,
-  ETHEREUM_MAINNET_CHAIN_ID,
-  HYPEREVM_MAINNET_CHAIN_ID,
-  KAIA_MAINNET_CHAIN_ID,
-  LIGHTLINK_MAINNET_CHAIN_ID,
-  OPTIMISM_MAINNET_CHAIN_ID,
-  POLYGON_MAINNET_CHAIN_ID,
-  REDBELLY_MAINNET_CHAIN_ID,
-  SONIC_MAINNET_CHAIN_ID,
-  type RpcConfig,
-  type XToken,
-} from '@sodax/types';
-import { getWagmiChainId, isNativeToken } from '@/utils';
-
-import { type Address, type Chain, defineChain, erc20Abi } from 'viem';
-import { getPublicClient } from 'wagmi/actions';
-import { type Config, createConfig, http, createStorage, cookieStorage } from 'wagmi';
-import {
-  mainnet,
-  avalanche,
-  base,
-  optimism,
-  polygon,
-  arbitrum,
-  bsc,
-  sonic,
-  lightlinkPhoenix,
-  redbellyMainnet,
-  kaia,
-} from 'wagmi/chains';
-import type { WagmiOptions } from '@/SodaxWalletProvider';
-
-// HyperEVM chain is not supported by viem, so we need to define it manually
-export const hyper = /*#__PURE__*/ defineChain({
-  id: 999,
-  name: 'HyperEVM',
-  nativeCurrency: {
-    decimals: 18,
-    name: 'HYPE',
-    symbol: 'HYPE',
-  },
-  rpcUrls: {
-    default: { http: ['https://rpc.hyperliquid.xyz/evm'] },
-  },
-  blockExplorers: {
-    default: {
-      name: 'HyperEVMScan',
-      url: 'https://hyperevmscan.io/',
-    },
-  },
-  contracts: {
-    multicall3: {
-      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
-      blockCreated: 13051,
-    },
-  },
-});
-
-export const createWagmiConfig = (config: RpcConfig, options?: WagmiOptions) => {
-  return createConfig({
-    chains: [
-      mainnet,
-      avalanche,
-      arbitrum,
-      base,
-      bsc,
-      sonic,
-      optimism,
-      polygon,
-      hyper,
-      lightlinkPhoenix,
-      kaia,
-      redbellyMainnet,
-    ],
-    ssr: options?.ssr,
-    transports: {
-      [mainnet.id]: http(config[ETHEREUM_MAINNET_CHAIN_ID]),
-      [avalanche.id]: http(config[AVALANCHE_MAINNET_CHAIN_ID]),
-      [arbitrum.id]: http(config[ARBITRUM_MAINNET_CHAIN_ID]),
-      [base.id]: http(config[BASE_MAINNET_CHAIN_ID]),
-      [bsc.id]: http(config[BSC_MAINNET_CHAIN_ID]),
-      [sonic.id]: http(config[SONIC_MAINNET_CHAIN_ID]),
-      [optimism.id]: http(config[OPTIMISM_MAINNET_CHAIN_ID]),
-      [polygon.id]: http(config[POLYGON_MAINNET_CHAIN_ID]),
-      [hyper.id]: http(config[HYPEREVM_MAINNET_CHAIN_ID]),
-      [lightlinkPhoenix.id]: http(config[LIGHTLINK_MAINNET_CHAIN_ID]),
-      [redbellyMainnet.id]: http(config[REDBELLY_MAINNET_CHAIN_ID]),
-      [kaia.id]: http(config[KAIA_MAINNET_CHAIN_ID]),
-    },
-    storage: createStorage({
-      storage: cookieStorage,
-      key: 'sodax',
-    }),
-  });
-};
-
-/**
- * Service class for handling EVM chain interactions.
- * Implements singleton pattern and provides methods for wallet/chain operations.
- */
-
-export class EvmXService extends XService {
-  private static instance: EvmXService;
-  public wagmiConfig: Config | undefined;
-
-  private constructor() {
-    super('EVM');
-  }
-
-  getXConnectors() {
-    return [];
-  }
-
-  public static getInstance(): EvmXService {
-    if (!EvmXService.instance) {
-      EvmXService.instance = new EvmXService();
-    }
-    return EvmXService.instance;
-  }
-
-  // get erc20 token balance in a chain (evm chain only)
-  async _getTokenBalance(address: string | undefined, chainId: number, tokenAddress: string): Promise<bigint> {
-    const publicClient = getPublicClient(this.wagmiConfig as Config, { chainId: chainId });
-    if (!publicClient) throw new Error('Public client not found');
-    const balance = await publicClient.readContract({
-      abi: erc20Abi,
-      address: tokenAddress as `0x${string}`,
-      functionName: 'balanceOf',
-      args: [address as `0x${string}`],
-    });
-    return balance || 0n;
-  }
-
-  //get native balance of the chain (evm chain only)
-  async _getChainBalance(address: string | undefined, chainId: number) {
-    const balance = await getPublicClient(this.wagmiConfig as Config, { chainId: chainId })?.getBalance({
-      address: address as Address,
-    });
-    return balance || 0n;
-  }
-
-  async getBalance(address: string | undefined, xToken: XToken): Promise<bigint> {
-    if (!address) return 0n;
-    if (!this.wagmiConfig) return 0n;
-
-    const chainId = getWagmiChainId(xToken.xChainId);
-
-    if (isNativeToken(xToken)) {
-      return this._getChainBalance(address, chainId);
-    }
-
-    throw new Error(`Unsupported token: ${xToken.symbol}`);
-  }
-
-  async getBalances(address: string | undefined, xTokens: XToken[]) {
-    if (!address) return {};
-    if (!this.wagmiConfig) return {};
-
-    const nativeTokenBalancePromises = xTokens
-      .filter(xToken => isNativeToken(xToken))
-      .map(async xToken => {
-        const balance = await this.getBalance(address, xToken);
-        return { symbol: xToken.symbol, address: xToken.address, balance };
-      });
-
-    const nativeTokenBalances = await Promise.all(nativeTokenBalancePromises);
-    const tokenMap = nativeTokenBalances.reduce((map, { address, balance }) => {
-      if (balance) map[address] = balance;
-      return map;
-    }, {});
-
-    const nonNativeXTokens = xTokens.filter(xToken => !isNativeToken(xToken));
-    const xChainId = xTokens[0].xChainId;
-    const viemChain: Chain = this.wagmiConfig.chains.find(chain => chain.id === getWagmiChainId(xChainId)) as Chain;
-    const chainId = getWagmiChainId(xChainId);
-
-    const publicClient = getPublicClient(this.wagmiConfig, { chainId: chainId });
-    if (!publicClient) throw new Error('Public client not found');
-
-    if (viemChain?.contracts?.multicall3) {
-      //multicall supports
-      const result = await publicClient.multicall({
-        contracts: nonNativeXTokens.map(token => ({
-          abi: erc20Abi,
-          address: token.address as `0x${string}`,
-          functionName: 'balanceOf',
-          args: [address],
-        })),
-      });
-
-      return nonNativeXTokens.reduce((acc, token, index) => {
-        acc[token.address] = result?.[index]?.result?.toString() || '0';
-        return acc;
-      }, tokenMap);
-    }
-
-    const nonNativeTokenBalances: bigint[] = await Promise.all(
-      nonNativeXTokens.map(token => this._getTokenBalance(address, chainId, token.address)),
-    );
-
-    return nonNativeXTokens.reduce((acc, token, idx) => {
-      acc[token.address] = nonNativeTokenBalances[idx] || '0';
-      return acc;
-    }, tokenMap);
-  }
-}

package/src/xchains/evm/index.ts

@@ -1,3 +0,0 @@
-export { EvmXService } from './EvmXService';
-export { EvmXConnector } from './EvmXConnector';
-export { createWagmiConfig, createWagmiConfig as createWagmi } from './EvmXService';

package/src/xchains/icon/IconHanaXConnector.ts

@@ -1,39 +0,0 @@
-import type { XAccount } from '@/types';
-import { ICONexRequestEventType, ICONexResponseEventType, request } from './iconex';
-
-import { XConnector } from '@/core/XConnector';
-
-export class IconHanaXConnector extends XConnector {
-  constructor() {
-    super('ICON', 'Hana Wallet', 'hana');
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    const { hanaWallet } = window as any;
-    if (window && !hanaWallet && !hanaWallet?.isAvailable) {
-      window.open('https://chromewebstore.google.com/detail/hana-wallet/jfdlamikmbghhapbgfoogdffldioobgl', '_blank');
-      return;
-    }
-
-    const detail = await request({
-      type: ICONexRequestEventType.REQUEST_ADDRESS,
-    });
-
-    if (detail?.type === ICONexResponseEventType.RESPONSE_ADDRESS) {
-      return {
-        address: detail?.payload,
-        xChainType: this.xChainType,
-      };
-    }
-
-    return undefined;
-  }
-
-  async disconnect(): Promise<void> {
-    console.log('HanaIconXConnector disconnected');
-  }
-
-  public get icon() {
-    return 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/hana.svg';
-  }
-}