@kaspacom/swap-sdk 1.1.3 → 1.1.4

package/dist/index.d.ts

@@ -0,0 +1,239 @@
+import { Trade, Pair } from '@uniswap/v2-sdk';
+import { Currency, TradeType, Token } from '@uniswap/sdk-core';
+import { Eip1193Provider, BrowserProvider, JsonRpcProvider, Signer, Contract, ContractTransactionResponse, TransactionResponse } from 'ethers';
+
+interface Erc20Token {
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    balance?: number;
+    rawBalance?: string;
+    logoURI?: string;
+}
+interface SwapSettings {
+    maxSlippage: string;
+    swapDeadline: number;
+}
+interface SwapState {
+    needsApproval: boolean;
+    isApproved: boolean;
+    isApproving: boolean;
+    isSwapping: boolean;
+    error: string | null;
+    success: boolean;
+    transactionHash: string | null;
+    status: string | null;
+    expectedAmountOut: string | null;
+    isCalculating: boolean;
+}
+interface SwapSectionData {
+    title: string;
+    amount: string;
+    usdValue: string;
+}
+interface SwapSdkOptions {
+    networkConfig: SwapSdkNetworkConfig | string;
+    walletProvider?: Eip1193Provider;
+    partnerKey?: string;
+    onChange?: (state: SwapControllerOutput, patch: Partial<SwapControllerOutput>) => Promise<void>;
+}
+interface SwapControllerInput {
+    fromToken?: Erc20Token | null;
+    toToken?: Erc20Token | null;
+    amount?: number;
+    isOutputAmount?: boolean;
+    settings?: Partial<SwapSettings>;
+}
+declare enum LoaderStatuses {
+    CALCULATING_QUOTE = 1,
+    APPROVING = 2,
+    SWAPPING = 3
+}
+interface ComputedAmounts {
+    maxAmountIn?: string;
+    minAmountOut?: string;
+    amountIn: string;
+    amountOut: string;
+    amountInRaw: string;
+    amountOutRaw: string;
+    maxAmountInRaw?: string;
+    minAmountOutRaw?: string;
+}
+interface SwapControllerOutput {
+    error?: string;
+    txHash?: string;
+    approveTxHash?: string;
+    tradeInfo?: Trade<Currency, Currency, TradeType.EXACT_INPUT> | Trade<Currency, Currency, TradeType.EXACT_OUTPUT>;
+    computed?: ComputedAmounts;
+    loader: LoaderStatuses | null;
+}
+interface SwapSdkNetworkConfig {
+    name: string;
+    chainId: number;
+    rpcUrl: string;
+    routerAddress: string;
+    factoryAddress: string;
+    proxyAddress?: string;
+    graphEndpoint: string;
+    blockExplorerUrl?: string;
+    additionalJsonRpcApiProviderOptionsOptions?: any;
+    nativeToken: Erc20Token;
+    wrappedToken: Erc20Token;
+}
+
+declare class WalletService {
+    private networkProvider;
+    private signer;
+    private address;
+    private config;
+    private injectedProvider?;
+    private walletProvider?;
+    constructor(config: SwapSdkNetworkConfig, injectedProvider?: Eip1193Provider);
+    connect(injectedProvider?: Eip1193Provider): Promise<string>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getAddress(): string | null;
+    getProvider(): BrowserProvider | JsonRpcProvider | null;
+    getSigner(): Signer | null;
+    getCurrentChainId(): Promise<number>;
+    connectWallet(): Promise<string>;
+    disconnectWallet(): void;
+}
+
+declare class SwapService {
+    private config;
+    private swapOptions;
+    private provider;
+    private signer;
+    private routerContract;
+    private factoryContract;
+    private proxyContract?;
+    private wethAddress;
+    private chainId;
+    private pairs;
+    private pairsLoadedPromise;
+    private resolvePairsLoaded;
+    private partnerFeeLoadedPromise;
+    private resolvePartnerFeeLoaded;
+    private partnerFee;
+    private wethToken;
+    constructor(provider: BrowserProvider | JsonRpcProvider, config: SwapSdkNetworkConfig, swapOptions: SwapSdkOptions);
+    loadPartnerFee(): Promise<bigint>;
+    setSigner(signer: Signer): void;
+    /**
+     * Rounds a number string to the specified number of decimal places
+     * to avoid parseUnits errors with too many decimals
+     */
+    private roundToDecimals;
+    /**
+     * Loads all pairs from The Graph and caches them as Uniswap SDK Pair instances.
+     * @param graphEndpoint The GraphQL endpoint URL
+     */
+    loadAllPairsFromGraph(): Promise<void>;
+    waitForPairsLoaded(): Promise<void>;
+    waitForPartnerFeeLoaded(): Promise<void>;
+    createSDKPair(pair: {
+        id: string;
+        token0: {
+            id: string;
+            symbol: string;
+            name: string;
+            decimals: string | number;
+        };
+        token1: {
+            id: string;
+            symbol: string;
+            name: string;
+            decimals: string | number;
+        };
+        reserve0?: string;
+        reserve1?: string;
+        positionValueUsd?: number;
+        totalTokens?: number;
+    }): Pair;
+    /**
+     * Returns the cached pairs for use in routing.
+     */
+    getPairs(): Pair[];
+    /**
+     * Finds the best trade path using Uniswap SDK for a given input amount.
+     * Returns the best path as an array of addresses, or null if no trade found.
+     */
+    private getBestTrade;
+    private trimTrailingZeros;
+    /**
+     *
+     * @param sellToken
+     * @param buyToken
+     * @param targetAmount
+     * @param isOutputAmount true if user input output (How much tokens to receive) and not input (how much tokens to sell)
+     * @param slippage
+     * @returns
+     */
+    calculateTrade(sellToken: Erc20Token, buyToken: Erc20Token, targetAmount: string, isOutputAmount: boolean, slippage: string): Promise<{
+        trade: Trade<Currency, Currency, TradeType.EXACT_INPUT> | Trade<Currency, Currency, TradeType.EXACT_OUTPUT>;
+        computed: ComputedAmounts;
+    }>;
+    checkApproval(tokenAddress: string, amount: string, spenderAddress: string): Promise<boolean>;
+    isApprovalNeeded(fromToken: Erc20Token, amountInWei: bigint): Promise<{
+        isApprovalNeeded: boolean;
+        tokenContract?: Contract;
+        signerAddress?: string;
+        allowanceTo?: string;
+    }>;
+    approveIfNeedApproval(fromToken: Erc20Token, amountInWei: bigint): Promise<ContractTransactionResponse | null>;
+    swapTokens(fromToken: Erc20Token, toToken: Erc20Token, amountInWei: string, amountOutWei: string, path: string[], isOutputAmount: boolean, deadline: number): Promise<TransactionResponse>;
+    getPairAddress(tokenA: string, tokenB: string): Promise<string>;
+    checkLiquidityExists(tokenA: string, tokenB: string): Promise<boolean>;
+    createTrade(fromToken: Erc20Token, toToken: Erc20Token, amountIn: string, slippageTolerance?: number): Promise<Trade<Token, Token, TradeType>>;
+    /**
+     * Fetch tokens from the graph endpoint (subgraph)
+     * @param graphEndpoint The GraphQL endpoint URL
+     * @param search Optional search string for symbol or name
+     */
+    getTokensFromGraph(limit?: number, search?: string): Promise<Erc20Token[]>;
+    /**
+     * Concatenates bytes: selector, array of bytes (each element is Uint8Array), array length (uint8, 1 byte), marker (bytes16(keccak256(markerString)))
+     * @param selectorBytes Uint8Array — function selector (usually 4 bytes)
+     * @param arrayOfBytes Uint8Array[] — array of bytes (each element is Uint8Array)
+     * @param markerString string — string from which bytes16(keccak256(...)) will be derived
+     * @returns Uint8Array — concatenated result
+     */
+    private concatSelectorAndParams;
+}
+
+declare const DEFAULT_SETTINGS: SwapSettings;
+declare class SwapSdkController {
+    private walletService;
+    private swapService;
+    private state;
+    private input;
+    private options;
+    constructor(options: SwapSdkOptions);
+    private initServices;
+    private setChange;
+    connectWallet(injectedProvider?: Eip1193Provider): Promise<string>;
+    disconnectWallet(): void;
+    getState(): SwapControllerOutput;
+    private get settings();
+    calculateQuoteIfNeeded(): Promise<void>;
+    setData(input: Partial<SwapControllerInput>): Promise<SwapControllerOutput>;
+    isNeedApproval(): Promise<boolean>;
+    approveIfNeeded(): Promise<string | undefined>;
+    swap(): Promise<string>;
+    getPartnerFee(): Promise<number>;
+    getTokensFromGraph(limit?: number, search?: string): Promise<Erc20Token[]>;
+    get currentNetworkConfig(): SwapSdkNetworkConfig;
+}
+
+declare const NETWORKS: Record<string, SwapSdkNetworkConfig>;
+
+/**
+ * Create a new headless swap controller
+ * @param options Configuration options for the controller
+ * @returns SwapSdkController instance
+ */
+declare function createKaspaComSwapController(options: SwapSdkOptions): SwapSdkController;
+
+export { type ComputedAmounts, DEFAULT_SETTINGS as DEFAULT_SWAP_SETTINGS, type Erc20Token, LoaderStatuses, NETWORKS, type SwapControllerInput, type SwapControllerOutput, SwapSdkController, type SwapSdkNetworkConfig, type SwapSdkOptions, type SwapSectionData, SwapService, type SwapSettings, type SwapState, WalletService, createKaspaComSwapController };