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

package/dist/xchains/bitcoin/index.d.ts

@@ -0,0 +1,125 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { XToken, IBitcoinWalletProvider, BtcWalletAddressType } from '@sodax/types';
+export { BtcWalletAddressType } from '@sodax/types';
+import { BitcoinWalletDefaults } from '@sodax/wallet-sdk-core';
+import { AddressPurpose } from 'sats-connect';
+
+declare class BitcoinXService extends XService {
+    private static instance;
+    private rpcUrl;
+    private constructor();
+    static getInstance(rpcUrl?: string): BitcoinXService;
+    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
+}
+
+/**
+ * Abstract base class for Bitcoin wallet connectors.
+ * Subclasses implement wallet-specific connection logic (Unisat, Xverse, OKX).
+ *
+ * `defaults` carries per-call overrides forwarded to the wallet provider built
+ * by each subclass. Currently honored field: `defaultFinalize` — applied to
+ * `signTransaction` when the caller omits the `finalize` argument.
+ */
+declare abstract class BitcoinXConnector extends XConnector {
+    protected readonly defaults: BitcoinWalletDefaults | undefined;
+    constructor(name: string, id: string, defaults?: BitcoinWalletDefaults);
+    getXService(): BitcoinXService;
+    abstract connect(): Promise<XAccount | undefined>;
+    abstract disconnect(): Promise<void>;
+    /**
+     * Returns an IBitcoinWalletProvider instance after connecting.
+     * Used by useSpokeProvider to build BitcoinSpokeProvider.
+     */
+    abstract getWalletProvider(): IBitcoinWalletProvider | undefined;
+    /**
+     * Recreates a walletProvider from the browser extension window object
+     * and stored xAccount data (no connect() call, no popup).
+     * Used to restore provider after page reload without requiring reconnect.
+     */
+    abstract recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
+}
+
+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;
+    }
+}
+declare class UnisatXConnector extends BitcoinXConnector {
+    private walletProvider;
+    constructor(defaults?: BitcoinWalletDefaults);
+    static isAvailable(): boolean;
+    get isInstalled(): boolean;
+    get installUrl(): string;
+    get icon(): string;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    getWalletProvider(): IBitcoinWalletProvider | undefined;
+    recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
+}
+
+declare class XverseXConnector extends BitcoinXConnector {
+    private walletProvider;
+    /** Address purpose used when connecting. Taproot (Ordinals) by default to match Radfi. */
+    addressPurpose: AddressPurpose;
+    constructor(defaults?: BitcoinWalletDefaults);
+    /** Set address purpose and persist to localStorage. */
+    setAddressPurpose(type: BtcWalletAddressType): void;
+    static isAvailable(): boolean;
+    get isInstalled(): boolean;
+    get installUrl(): string;
+    get icon(): string;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    getWalletProvider(): IBitcoinWalletProvider | undefined;
+    recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
+}
+
+interface OKXBitcoinWallet {
+    getAccounts(): Promise<string[]>;
+    getPublicKey(): Promise<string>;
+    signPsbt(psbtHex: string, options?: {
+        autoFinalized?: boolean;
+    }): Promise<string>;
+    signMessage(message: string, type?: 'bip322-simple' | 'ecdsa'): Promise<string>;
+    connect(): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    sendBitcoin(toAddress: string, satoshis: number): Promise<string>;
+}
+declare global {
+    interface Window {
+        okxwallet?: {
+            bitcoin?: OKXBitcoinWallet;
+        };
+    }
+}
+declare class OKXXConnector extends BitcoinXConnector {
+    private walletProvider;
+    constructor(defaults?: BitcoinWalletDefaults);
+    static isAvailable(): boolean;
+    get isInstalled(): boolean;
+    get installUrl(): string;
+    get icon(): string;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    getWalletProvider(): IBitcoinWalletProvider | undefined;
+    recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
+}
+
+/**
+ * Hook to return available Bitcoin wallet connectors from the globally registered xService.
+ */
+declare function useBitcoinXConnectors(): BitcoinXConnector[];
+
+export { BitcoinXConnector, BitcoinXService, OKXXConnector, UnisatXConnector, XverseXConnector, useBitcoinXConnectors };

package/dist/xchains/bitcoin/index.mjs

@@ -0,0 +1,14 @@
+export { BitcoinXConnector, BitcoinXService, OKXXConnector, UnisatXConnector, XverseXConnector, useBitcoinXConnectors } from '../../chunk-DQTYAMKF.mjs';
+import '../../chunk-X7BHR7WS.mjs';
+import '../../chunk-JQ4H4GJ5.mjs';
+import '../../chunk-Z5GXDHGL.mjs';
+import '../../chunk-MWWVB7TD.mjs';
+import '../../chunk-C6M34IVL.mjs';
+import '../../chunk-FSOGMSJH.mjs';
+import '../../chunk-WPZOLGVB.mjs';
+import '../../chunk-TACW7Z4D.mjs';
+import '../../chunk-NAKCAL2M.mjs';
+import '../../chunk-7V7O3Q7Y.mjs';
+import '../../chunk-OPYSVPRW.mjs';
+import '../../chunk-QMXBY3UI.mjs';
+import '../../chunk-IFXZQW4C.mjs';

package/dist/xchains/evm/index.d.ts

@@ -0,0 +1,39 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { XToken } from '@sodax/types';
+import { f as EvmTypeConfig } from '../../config-DEsqgrG1.js';
+import { Config, CreateConnectorFn, Connector } from 'wagmi';
+import '@sodax/wallet-sdk-core';
+import 'wagmi/connectors';
+
+type WagmiOptions = {
+    reconnectOnMount?: boolean;
+    ssr?: boolean;
+};
+declare const createWagmiConfig: (evmChains?: EvmTypeConfig["chains"], options?: WagmiOptions & {
+    connectors?: CreateConnectorFn[];
+}) => Config;
+/**
+ * Service class for handling EVM chain interactions.
+ * Implements singleton pattern and provides methods for wallet/chain operations.
+ */
+declare class EvmXService extends XService {
+    private static instance;
+    wagmiConfig: Config | undefined;
+    private constructor();
+    static getInstance(): EvmXService;
+    _getTokenBalance(address: string | undefined, chainId: number, tokenAddress: string): Promise<bigint>;
+    _getChainBalance(address: string | undefined, chainId: number): Promise<bigint>;
+    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
+    getBalances(address: string | undefined, xTokens: XToken[]): Promise<Record<string, bigint>>;
+}
+
+declare class EvmXConnector extends XConnector {
+    connector: Connector;
+    constructor(connector: Connector);
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    get id(): string;
+    get icon(): string | undefined;
+}
+
+export { EvmXConnector, EvmXService, createWagmiConfig as createWagmi, createWagmiConfig };

package/dist/xchains/evm/index.mjs

@@ -0,0 +1,3 @@
+export { EvmXConnector, EvmXService, createWagmiConfig as createWagmi, createWagmiConfig } from '../../chunk-Z5GXDHGL.mjs';
+import '../../chunk-7V7O3Q7Y.mjs';
+import '../../chunk-IFXZQW4C.mjs';

package/dist/xchains/icon/index.d.ts

@@ -0,0 +1,37 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { IconService } from 'icon-sdk-js';
+import { XToken } from '@sodax/types';
+
+declare enum SupportedChainId {
+    MAINNET = 1
+}
+interface ChainInfo {
+    readonly name: string;
+    readonly node: string;
+    readonly APIEndpoint: string;
+    readonly debugAPIEndpoint: string;
+    readonly chainId: number;
+    readonly tracker: string;
+}
+declare const CHAIN_INFO: {
+    readonly [chainId: number]: ChainInfo;
+};
+declare class IconXService extends XService {
+    private static instance;
+    iconService: IconService;
+    private constructor();
+    static getInstance(rpcUrl?: string): IconXService;
+    private getAggregateData;
+    getBalances(address: string | undefined, xTokens: XToken[]): Promise<Record<string, bigint>>;
+}
+
+declare class IconHanaXConnector extends XConnector {
+    constructor();
+    get isInstalled(): boolean;
+    get installUrl(): string;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    get icon(): string;
+}
+
+export { CHAIN_INFO, IconHanaXConnector, IconXService, SupportedChainId };

package/dist/xchains/icon/index.mjs

@@ -0,0 +1,5 @@
+export { CHAIN_INFO, IconHanaXConnector, IconXService, SupportedChainId } from '../../chunk-WPZOLGVB.mjs';
+import '../../chunk-TACW7Z4D.mjs';
+import '../../chunk-NAKCAL2M.mjs';
+import '../../chunk-7V7O3Q7Y.mjs';
+import '../../chunk-IFXZQW4C.mjs';

package/dist/xchains/injective/index.d.ts

@@ -0,0 +1,35 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { IndexerGrpcAccountPortfolioApi, ChainGrpcWasmApi } from '@injectivelabs/sdk-ts';
+import { MsgBroadcaster } from '@injectivelabs/wallet-core';
+import { InjectiveRpcConfig, XToken } from '@sodax/types';
+import { WalletStrategy } from '@sodax/libs/injective/wallet-strategy';
+import { Wallet } from '@injectivelabs/wallet-base';
+
+declare class InjectiveXService extends XService {
+    private static instance;
+    walletStrategy: WalletStrategy;
+    indexerGrpcAccountPortfolioApi: IndexerGrpcAccountPortfolioApi;
+    chainGrpcWasmApi: ChainGrpcWasmApi;
+    msgBroadcaster: MsgBroadcaster;
+    private constructor();
+    /**
+     * @param rpcConfig - Only applied on first call. Subsequent calls return the
+     *   existing instance unchanged — gRPC/Indexer clients are built in the
+     *   constructor and can't be rebuilt at runtime. Pass the desired endpoints
+     *   via `SodaxWalletProvider.config.rpcConfig` once at app init.
+     */
+    static getInstance(rpcConfig?: InjectiveRpcConfig): InjectiveXService;
+    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
+}
+
+declare class InjectiveXConnector extends XConnector {
+    private wallet;
+    constructor(name: string, wallet: Wallet);
+    getXService(): InjectiveXService;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    get icon(): string | undefined;
+    get isInstalled(): boolean;
+}
+
+export { InjectiveXConnector, InjectiveXService };

package/dist/xchains/injective/index.mjs

@@ -0,0 +1,3 @@
+export { InjectiveXConnector, InjectiveXService } from '../../chunk-MWWVB7TD.mjs';
+import '../../chunk-QMXBY3UI.mjs';
+import '../../chunk-IFXZQW4C.mjs';

package/dist/xchains/near/index.d.ts

@@ -0,0 +1,34 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { XToken } from '@sodax/types';
+import { NearConnector, NearWalletBase } from '@hot-labs/near-connect';
+
+declare class NearXService extends XService {
+    private static instance;
+    walletSelector: NearConnector;
+    rpcUrl: string;
+    /**
+     * @param rpcUrl - Used by `getBalance` via `JsonRpcProvider({ url: rpcUrl })`.
+     *   Does NOT affect `walletSelector` — `@hot-labs/near-connect` only accepts
+     *   the network preset name (`'mainnet'`/`'testnet'`) and fetches RPC internally.
+     *   Custom RPC is therefore read-only for balance queries.
+     */
+    private constructor();
+    /**
+     * @param rpcUrl - Re-applied on every call (matches StacksXService semantics).
+     *   `rpcUrl` only drives `getBalance` via a per-call `JsonRpcProvider`, so it's
+     *   safe to update at runtime — no persistent chain client to rebuild.
+     */
+    static getInstance(rpcUrl?: string): NearXService;
+    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
+}
+
+declare class NearXConnector extends XConnector {
+    _wallet: NearWalletBase;
+    constructor(wallet: NearWalletBase);
+    getXService(): NearXService;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    get icon(): string;
+}
+
+export { NearXConnector, NearXService };

package/dist/xchains/near/index.mjs

@@ -0,0 +1,4 @@
+export { NearXConnector, NearXService } from '../../chunk-C6M34IVL.mjs';
+import '../../chunk-NAKCAL2M.mjs';
+import '../../chunk-QMXBY3UI.mjs';
+import '../../chunk-IFXZQW4C.mjs';

package/dist/xchains/solana/index.d.ts

@@ -0,0 +1,26 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { XToken } from '@sodax/types';
+import { Connection } from '@solana/web3.js';
+import { WalletContextState, Wallet } from '@solana/wallet-adapter-react';
+
+declare class SolanaXService extends XService {
+    private static instance;
+    connection: Connection | undefined;
+    wallet: WalletContextState | undefined;
+    private constructor();
+    static getInstance(): SolanaXService;
+    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
+}
+
+declare class SolanaXConnector extends XConnector {
+    wallet: Wallet;
+    constructor(wallet: Wallet);
+    getXService(): SolanaXService;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    get icon(): string;
+    get isInstalled(): boolean;
+    get installUrl(): string | undefined;
+}
+
+export { SolanaXConnector, SolanaXService };

package/dist/xchains/solana/index.mjs

@@ -0,0 +1,5 @@
+export { SolanaXConnector } from '../../chunk-LKSSME2J.mjs';
+export { SolanaXService } from '../../chunk-FSOGMSJH.mjs';
+import '../../chunk-7V7O3Q7Y.mjs';
+import '../../chunk-QMXBY3UI.mjs';
+import '../../chunk-IFXZQW4C.mjs';

package/dist/xchains/stacks/index.d.ts

@@ -0,0 +1,42 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { StacksNetworkName, XToken } from '@sodax/types';
+import { StacksNetwork } from '@sodax/libs/stacks/core';
+import { StacksProvider } from '@sodax/libs/stacks/connect';
+
+declare class StacksXService extends XService {
+    private static instance;
+    network: StacksNetwork;
+    private constructor();
+    static getInstance(network?: StacksNetworkName | StacksNetwork): StacksXService;
+    /**
+     * @warning Network / fetch / contract-read failures are silently swallowed —
+     * `0n` is returned on any error. Callers cannot distinguish "zero balance"
+     * from "fetch failed"; UI that needs to surface the failure must wrap this
+     * call externally and re-fetch on its own error path.
+     */
+    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
+}
+
+interface StacksProviderConfig {
+    /** The provider ID matching the window path, e.g. 'LeatherProvider' or 'XverseProviders.BitcoinProvider' */
+    id: string;
+    name: string;
+    icon: string;
+    installUrl?: string;
+}
+declare class StacksXConnector extends XConnector {
+    private readonly config;
+    constructor(config: StacksProviderConfig);
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    get icon(): string;
+    get isInstalled(): boolean;
+    get installUrl(): string | undefined;
+    getProvider(): StacksProvider | undefined;
+}
+
+declare const STACKS_PROVIDERS: StacksProviderConfig[];
+
+declare function useStacksXConnectors(): StacksXConnector[];
+
+export { STACKS_PROVIDERS, type StacksProviderConfig, StacksXConnector, StacksXService, useStacksXConnectors };

package/dist/xchains/stacks/index.mjs

@@ -0,0 +1,3 @@
+export { STACKS_PROVIDERS, StacksXConnector, StacksXService, useStacksXConnectors } from '../../chunk-OPYSVPRW.mjs';
+import '../../chunk-QMXBY3UI.mjs';
+import '../../chunk-IFXZQW4C.mjs';

package/dist/xchains/stellar/index.d.ts

@@ -0,0 +1,44 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { StellarWalletsKit } from '@creit.tech/stellar-wallets-kit';
+import * as StellarSdk from '@stellar/stellar-sdk';
+import { rpc, Transaction, Memo, MemoType, Operation, FeeBumpTransaction } from '@stellar/stellar-sdk';
+import { XToken } from '@sodax/types';
+
+declare class CustomSorobanServer extends rpc.Server {
+    private readonly customHeaders;
+    constructor(serverUrl: string, customHeaders: Record<string, string>);
+    simulateTransaction(tx: Transaction<Memo<MemoType>, Operation[]>): Promise<rpc.Api.SimulateTransactionResponse>;
+    sendTransaction(tx: Transaction | FeeBumpTransaction): Promise<rpc.Api.SendTransactionResponse>;
+    getTransaction(hash: string): Promise<rpc.Api.GetTransactionResponse>;
+}
+
+declare class StellarXService extends XService {
+    private static instance;
+    walletsKit: StellarWalletsKit;
+    server: StellarSdk.Horizon.Server;
+    sorobanServer: CustomSorobanServer;
+    private constructor();
+    static getInstance(horizonRpcUrl?: string, sorobanRpcUrl?: string): StellarXService;
+    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
+}
+
+type StellarWalletType = {
+    icon: string;
+    id: string;
+    isAvailable: boolean;
+    name: string;
+    type: string;
+    url: string;
+};
+declare class StellarWalletsKitXConnector extends XConnector {
+    _wallet: StellarWalletType;
+    constructor(wallet: StellarWalletType);
+    getXService(): StellarXService;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    get icon(): string;
+    get isInstalled(): boolean;
+    get installUrl(): string | undefined;
+}
+
+export { StellarWalletsKitXConnector, StellarXService };

package/dist/xchains/stellar/index.mjs

@@ -0,0 +1,4 @@
+export { StellarWalletsKitXConnector, StellarXService } from '../../chunk-X7BHR7WS.mjs';
+import '../../chunk-NAKCAL2M.mjs';
+import '../../chunk-QMXBY3UI.mjs';
+import '../../chunk-IFXZQW4C.mjs';

package/dist/xchains/sui/index.d.ts

@@ -0,0 +1,37 @@
+import { d as XService, c as XConnector, X as XAccount } from '../../XConnector-12q0OVe5.js';
+import { ISuiWalletProvider, XToken } from '@sodax/types';
+
+interface SuiClientLike {
+    getBalance(input: {
+        owner: string;
+        coinType: string;
+    }): Promise<{
+        totalBalance: string;
+    }>;
+}
+declare class SuiXService extends XService {
+    private static instance;
+    suiClient: SuiClientLike | undefined;
+    suiWallet: unknown;
+    suiAccount: unknown;
+    private constructor();
+    static getInstance(): SuiXService;
+    createWalletProvider(): ISuiWalletProvider | undefined;
+    getBalances(address: string | undefined, xTokens: readonly XToken[]): Promise<Record<string, bigint>>;
+}
+
+interface SuiWalletInfo {
+    id?: string;
+    name: string;
+    icon?: string;
+}
+declare class SuiXConnector extends XConnector {
+    readonly wallet: SuiWalletInfo;
+    constructor(wallet: unknown);
+    getXService(): SuiXService;
+    connect(): Promise<XAccount | undefined>;
+    disconnect(): Promise<void>;
+    get icon(): string | undefined;
+}
+
+export { SuiXConnector, SuiXService };

package/dist/xchains/sui/index.mjs

@@ -0,0 +1,5 @@
+export { SuiXConnector, SuiXService } from '../../chunk-JQ4H4GJ5.mjs';
+import '../../chunk-TACW7Z4D.mjs';
+import '../../chunk-7V7O3Q7Y.mjs';
+import '../../chunk-QMXBY3UI.mjs';
+import '../../chunk-IFXZQW4C.mjs';