@sun-protocol/sun-sdk-sunswap-v2 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,356 @@
+import { Network, TronAddress, Token, BigintIsh, ContractCallAction, Percent, CurrencyAmount, Price, Currency, TradeType, ContractParameter } from '@sun-protocol/sun-sdk-core';
+import JSBI from 'jsbi';
+
+declare const V2_ROUTER_SELECTORS: {
+    readonly addLiquidity: "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+    readonly addLiquidityETH: "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+    readonly removeLiquidity: "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+    readonly removeLiquidityETH: "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+    readonly swapExactETHForTokens: "swapExactETHForTokens(uint256,address[],address,uint256)";
+    readonly swapETHForExactTokens: "swapETHForExactTokens(uint256,address[],address,uint256)";
+    readonly swapExactTokensForETH: "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+    readonly swapExactTokensForTokens: "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+    readonly swapTokensForExactETH: "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+    readonly swapTokensForExactTokens: "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+};
+interface V2ActionOptions {
+    readonly network: Network;
+    readonly router?: TronAddress;
+    readonly feeLimit?: number;
+    readonly id?: string;
+}
+interface BuildV2AddLiquidityActionParams extends V2ActionOptions {
+    readonly tokenA: Token;
+    readonly tokenB: Token;
+    readonly amountADesired: BigintIsh;
+    readonly amountBDesired: BigintIsh;
+    readonly amountAMin: BigintIsh;
+    readonly amountBMin: BigintIsh;
+    readonly recipient: TronAddress;
+    readonly deadline: BigintIsh;
+}
+interface BuildV2RemoveLiquidityActionParams extends V2ActionOptions {
+    readonly tokenA: Token;
+    readonly tokenB: Token;
+    readonly liquidity: BigintIsh;
+    readonly amountAMin: BigintIsh;
+    readonly amountBMin: BigintIsh;
+    readonly recipient: TronAddress;
+    readonly deadline: BigintIsh;
+}
+interface BuildV2AddLiquidityEthActionParams extends V2ActionOptions {
+    readonly token: Token;
+    readonly amountTokenDesired: BigintIsh;
+    readonly amountEthDesired: BigintIsh;
+    readonly amountTokenMin: BigintIsh;
+    readonly amountEthMin: BigintIsh;
+    readonly recipient: TronAddress;
+    readonly deadline: BigintIsh;
+}
+interface BuildV2RemoveLiquidityEthActionParams extends V2ActionOptions {
+    readonly token: Token;
+    readonly liquidity: BigintIsh;
+    readonly amountTokenMin: BigintIsh;
+    readonly amountEthMin: BigintIsh;
+    readonly recipient: TronAddress;
+    readonly deadline: BigintIsh;
+}
+interface V2SwapActionOptions extends V2ActionOptions {
+    readonly path: readonly TronAddress[];
+    readonly recipient: TronAddress;
+    readonly deadline: BigintIsh;
+}
+interface BuildV2SwapExactEthForTokensActionParams extends V2SwapActionOptions {
+    readonly amountIn: BigintIsh;
+    readonly amountOutMin: BigintIsh;
+}
+interface BuildV2SwapEthForExactTokensActionParams extends V2SwapActionOptions {
+    readonly amountOut: BigintIsh;
+    readonly amountInMax: BigintIsh;
+}
+interface BuildV2SwapExactTokensForEthActionParams extends V2SwapActionOptions {
+    readonly amountIn: BigintIsh;
+    readonly amountOutMin: BigintIsh;
+}
+interface BuildV2SwapExactTokensForTokensActionParams extends V2SwapActionOptions {
+    readonly amountIn: BigintIsh;
+    readonly amountOutMin: BigintIsh;
+}
+interface BuildV2SwapTokensForExactEthActionParams extends V2SwapActionOptions {
+    readonly amountOut: BigintIsh;
+    readonly amountInMax: BigintIsh;
+}
+interface BuildV2SwapTokensForExactTokensActionParams extends V2SwapActionOptions {
+    readonly amountOut: BigintIsh;
+    readonly amountInMax: BigintIsh;
+}
+declare function buildV2AddLiquidityAction(params: BuildV2AddLiquidityActionParams): ContractCallAction;
+declare function buildV2RemoveLiquidityAction(params: BuildV2RemoveLiquidityActionParams): ContractCallAction;
+declare function buildV2AddLiquidityEthAction(params: BuildV2AddLiquidityEthActionParams): ContractCallAction;
+declare function buildV2RemoveLiquidityEthAction(params: BuildV2RemoveLiquidityEthActionParams): ContractCallAction;
+declare function buildV2SwapExactEthForTokensAction(params: BuildV2SwapExactEthForTokensActionParams): ContractCallAction;
+declare function buildV2SwapEthForExactTokensAction(params: BuildV2SwapEthForExactTokensActionParams): ContractCallAction;
+declare function buildV2SwapExactTokensForEthAction(params: BuildV2SwapExactTokensForEthActionParams): ContractCallAction;
+declare function buildV2SwapExactTokensForTokensAction(params: BuildV2SwapExactTokensForTokensActionParams): ContractCallAction;
+declare function buildV2SwapTokensForExactEthAction(params: BuildV2SwapTokensForExactEthActionParams): ContractCallAction;
+declare function buildV2SwapTokensForExactTokensAction(params: BuildV2SwapTokensForExactTokensActionParams): ContractCallAction;
+declare function buildV2LpApproveAction(params: {
+    readonly pair: TronAddress;
+    readonly spender: TronAddress;
+    readonly amount: BigintIsh;
+    readonly feeLimit?: number;
+    readonly id?: string;
+}): ContractCallAction;
+
+declare const FACTORY_ADDRESS = "0x689abaeeed3f0bb3585773192e23224cac25dd41";
+declare const FACTORY_ADDRESS_MAP: {
+    [chainId: number]: string;
+};
+declare const INIT_CODE_HASH = "0x6d3f89421f83e4b62e628de8fc7ff2b014a79bf8fd8e8b0ea46e4a1d9409b67d";
+declare const INIT_CODE_HASH_MAP: {
+    [chainId: number]: string;
+};
+declare const MINIMUM_LIQUIDITY: JSBI;
+declare const ZERO: JSBI;
+declare const ONE: JSBI;
+declare const FIVE: JSBI;
+declare const _997: JSBI;
+declare const _1000: JSBI;
+declare const BASIS_POINTS: JSBI;
+declare const ZERO_PERCENT: Percent;
+declare const ONE_HUNDRED_PERCENT: Percent;
+
+declare class InsufficientReservesError extends Error {
+    readonly isInsufficientReservesError: true;
+    constructor();
+}
+declare class InsufficientInputAmountError extends Error {
+    readonly isInsufficientInputAmountError: true;
+    constructor();
+}
+
+declare const computePairAddress: ({ factoryAddress, tokenA, tokenB, initCodeHashManualOverride, }: {
+    factoryAddress: string;
+    tokenA: Token;
+    tokenB: Token;
+    initCodeHashManualOverride?: string;
+}) => string;
+declare class Pair {
+    readonly liquidityToken: Token;
+    private readonly tokenAmounts;
+    static getAddress(tokenA: Token, tokenB: Token): string;
+    constructor(currencyAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>);
+    involvesToken(token: Token): boolean;
+    get token0Price(): Price<Token, Token>;
+    get token1Price(): Price<Token, Token>;
+    priceOf(token: Token): Price<Token, Token>;
+    get chainId(): number;
+    get token0(): Token;
+    get token1(): Token;
+    get reserve0(): CurrencyAmount<Token>;
+    get reserve1(): CurrencyAmount<Token>;
+    reserveOf(token: Token): CurrencyAmount<Token>;
+    getOutputAmount(inputAmount: CurrencyAmount<Token>, calculateFotFees?: boolean): [CurrencyAmount<Token>, Pair];
+    getInputAmount(outputAmount: CurrencyAmount<Token>, calculateFotFees?: boolean): [CurrencyAmount<Token>, Pair];
+    getLiquidityMinted(totalSupply: CurrencyAmount<Token>, tokenAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>): CurrencyAmount<Token>;
+    getLiquidityValue(token: Token, totalSupply: CurrencyAmount<Token>, liquidity: CurrencyAmount<Token>, feeOn?: boolean, kLast?: BigintIsh): CurrencyAmount<Token>;
+    private derivePercentAfterSellFees;
+    private derivePercentAfterBuyFees;
+}
+
+declare class Route<TInput extends Currency, TOutput extends Currency> {
+    readonly pairs: Pair[];
+    readonly path: Token[];
+    readonly input: TInput;
+    readonly output: TOutput;
+    private _midPrice;
+    constructor(pairs: Pair[], input: TInput, output?: TOutput);
+    get midPrice(): Price<TInput, TOutput>;
+    get chainId(): number;
+}
+
+interface InputOutput<TInput extends Currency, TOutput extends Currency> {
+    readonly inputAmount: CurrencyAmount<TInput>;
+    readonly outputAmount: CurrencyAmount<TOutput>;
+}
+declare function inputOutputComparator<TInput extends Currency, TOutput extends Currency>(a: InputOutput<TInput, TOutput>, b: InputOutput<TInput, TOutput>): number;
+declare function tradeComparator<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(a: Trade<TInput, TOutput, TTradeType>, b: Trade<TInput, TOutput, TTradeType>): number;
+interface BestTradeOptions {
+    maxNumResults?: number;
+    maxHops?: number;
+}
+declare class Trade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly route: Route<TInput, TOutput>;
+    readonly tradeType: TTradeType;
+    readonly inputAmount: CurrencyAmount<TInput>;
+    readonly outputAmount: CurrencyAmount<TOutput>;
+    readonly executionPrice: Price<TInput, TOutput>;
+    readonly priceImpact: Percent;
+    static exactIn<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountIn: CurrencyAmount<TInput>): Trade<TInput, TOutput, TradeType.EXACT_INPUT>;
+    static exactOut<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountOut: CurrencyAmount<TOutput>): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>;
+    constructor(route: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType);
+    minimumAmountOut(slippageTolerance: Percent): CurrencyAmount<TOutput>;
+    maximumAmountIn(slippageTolerance: Percent): CurrencyAmount<TInput>;
+    static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(pairs: Pair[], currencyAmountIn: CurrencyAmount<TInput>, currencyOut: TOutput, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], nextAmountIn?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]): Trade<TInput, TOutput, TradeType.EXACT_INPUT>[];
+    worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput>;
+    static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(pairs: Pair[], currencyIn: TInput, currencyAmountOut: CurrencyAmount<TOutput>, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], nextAmountOut?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[];
+}
+
+interface V2ContractReadSpec {
+    readonly target: TronAddress;
+    readonly functionSelector: string;
+    readonly parameters?: readonly ContractParameter[];
+    readonly outputs?: readonly {
+        readonly type: string;
+        readonly name?: string;
+    }[];
+    readonly metadata?: Record<string, unknown>;
+}
+declare const V2_PAIR_READ_SELECTORS: {
+    readonly getReserves: "getReserves()";
+    readonly totalSupply: "totalSupply()";
+    readonly kLast: "kLast()";
+    readonly balanceOf: "balanceOf(address)";
+    readonly allowance: "allowance(address,address)";
+};
+declare const V2_FACTORY_READ_SELECTORS: {
+    readonly getPair: "getPair(address,address)";
+    readonly feeTo: "feeTo()";
+};
+declare const V2_ROUTER_READ_SELECTORS: {
+    readonly getAmountsOut: "getAmountsOut(uint256,address[])";
+    readonly getAmountsIn: "getAmountsIn(uint256,address[])";
+    readonly isAllowedTradingPair: "isAllowedTradingPair(address,address)";
+};
+interface V2RouterReadOptions {
+    readonly network: Network;
+    readonly router?: TronAddress;
+}
+interface V2FactoryReadOptions {
+    readonly network: Network;
+    readonly factory?: TronAddress;
+}
+interface BuildV2FactoryPairReadParams extends V2FactoryReadOptions {
+    readonly tokenA: TronAddress;
+    readonly tokenB: TronAddress;
+}
+interface BuildV2RouterAmountsOutReadParams extends V2RouterReadOptions {
+    readonly amountIn: BigintIsh;
+    readonly path: readonly TronAddress[];
+}
+interface BuildV2RouterAmountsInReadParams extends V2RouterReadOptions {
+    readonly amountOut: BigintIsh;
+    readonly path: readonly TronAddress[];
+}
+interface BuildV2RouterAllowedTradingPairReadParams extends V2RouterReadOptions {
+    readonly tokenA: TronAddress;
+    readonly tokenB: TronAddress;
+}
+declare function buildV2PairReservesRead(pair: TronAddress): V2ContractReadSpec;
+declare function buildV2PairTotalSupplyRead(pair: TronAddress): V2ContractReadSpec;
+declare function buildV2PairKLastRead(pair: TronAddress): V2ContractReadSpec;
+declare function buildV2PairBalanceRead(pair: TronAddress, owner: TronAddress): V2ContractReadSpec;
+declare function buildV2PairAllowanceRead(pair: TronAddress, owner: TronAddress, spender: TronAddress): V2ContractReadSpec;
+declare function buildV2FactoryPairRead(params: BuildV2FactoryPairReadParams): V2ContractReadSpec;
+declare function buildV2FactoryFeeToRead(params: V2FactoryReadOptions): V2ContractReadSpec;
+declare function buildV2RouterAmountsOutRead(params: BuildV2RouterAmountsOutReadParams): V2ContractReadSpec;
+declare function buildV2RouterAmountsInRead(params: BuildV2RouterAmountsInReadParams): V2ContractReadSpec;
+declare function buildV2RouterAllowedTradingPairRead(params: BuildV2RouterAllowedTradingPairReadParams): V2ContractReadSpec;
+declare function normalizeV2ReserveResult(result: readonly unknown[]): {
+    reserve0: string;
+    reserve1: string;
+};
+declare function normalizeV2AmountsResult(result: unknown): string[];
+
+interface TradeOptions {
+    readonly allowedSlippage: Percent;
+    readonly ttl: number;
+    readonly recipient: string;
+    readonly feeOnTransfer?: boolean;
+}
+interface TradeOptionsDeadline extends Omit<TradeOptions, 'ttl'> {
+    readonly deadline: number;
+}
+interface SwapParameters {
+    readonly methodName: string;
+    readonly args: (string | string[])[];
+    readonly value: string;
+}
+declare abstract class Router {
+    private constructor();
+    static swapCallParameters(trade: Trade<Currency, Currency, TradeType>, options: TradeOptions | TradeOptionsDeadline): SwapParameters;
+}
+
+interface V2PairKey {
+    readonly network: Network;
+    readonly token0: Token;
+    readonly token1: Token;
+}
+interface V2PairState {
+    readonly pair: TronAddress;
+    readonly pairKey: V2PairKey;
+    readonly reserve0: string;
+    readonly reserve1: string;
+    readonly totalSupply?: string;
+}
+interface V2LiquidityAmounts {
+    readonly amountA: string;
+    readonly amountB: string;
+}
+interface V2AddLiquidityAmounts extends V2LiquidityAmounts {
+    readonly amountAMin: string;
+    readonly amountBMin: string;
+}
+interface V2RemoveLiquidityAmounts {
+    readonly liquidity: string;
+    readonly amountAMin: string;
+    readonly amountBMin: string;
+}
+interface V2TokenPairAmountInput {
+    readonly tokenA: Token;
+    readonly tokenB: Token;
+    readonly amountA: BigintIsh;
+    readonly amountB: BigintIsh;
+}
+
+declare const V2_INIT_CODE_HASH: Record<Network, `0x${string}`>;
+interface ComputeV2PairAddressParams {
+    readonly network: Network;
+    readonly tokenA: TronAddress | string;
+    readonly tokenB: TronAddress | string;
+    readonly factory?: TronAddress | string;
+    readonly initCodeHash?: string;
+    readonly wrappedNative?: TronAddress | string;
+}
+declare function sortV2Tokens(tokenA: Token, tokenB: Token): readonly [Token, Token];
+declare function tronAddressToEvmHex(address: string, label?: string): string;
+declare function evmHexToTronAddress(address: string, label?: string): TronAddress;
+declare function tronCreate2Address(params: {
+    readonly factoryAddress: string;
+    readonly salt: string;
+    readonly initCodeHash: string;
+}): TronAddress;
+declare function computeV2PairAddress(params: ComputeV2PairAddressParams): TronAddress;
+declare function createV2PairKey(input: {
+    network: V2PairKey['network'];
+    tokenA: Token;
+    tokenB: Token;
+}): V2PairKey;
+declare function quoteV2LiquidityAmount(amountA: BigintIsh, reserveA: BigintIsh, reserveB: BigintIsh): string;
+declare function applyV2SlippageMin(amount: BigintIsh, slippageTolerance: Percent): string;
+declare function getV2AddLiquidityMinimums(amounts: {
+    amountA: BigintIsh;
+    amountB: BigintIsh;
+}, slippageTolerance: Percent): {
+    amountAMin: string;
+    amountBMin: string;
+};
+declare function getV2RemoveLiquidityMinimums(amounts: {
+    amountA: BigintIsh;
+    amountB: BigintIsh;
+}, slippageTolerance: Percent): {
+    amountAMin: string;
+    amountBMin: string;
+};
+
+export { BASIS_POINTS, type BestTradeOptions, type BuildV2AddLiquidityActionParams, type BuildV2AddLiquidityEthActionParams, type BuildV2FactoryPairReadParams, type BuildV2RemoveLiquidityActionParams, type BuildV2RemoveLiquidityEthActionParams, type BuildV2RouterAllowedTradingPairReadParams, type BuildV2RouterAmountsInReadParams, type BuildV2RouterAmountsOutReadParams, type BuildV2SwapEthForExactTokensActionParams, type BuildV2SwapExactEthForTokensActionParams, type BuildV2SwapExactTokensForEthActionParams, type BuildV2SwapExactTokensForTokensActionParams, type BuildV2SwapTokensForExactEthActionParams, type BuildV2SwapTokensForExactTokensActionParams, type ComputeV2PairAddressParams, FACTORY_ADDRESS, FACTORY_ADDRESS_MAP, FIVE, INIT_CODE_HASH, INIT_CODE_HASH_MAP, InsufficientInputAmountError, InsufficientReservesError, MINIMUM_LIQUIDITY, ONE, ONE_HUNDRED_PERCENT, Pair, Route, Router, type SwapParameters, Trade, type TradeOptions, type TradeOptionsDeadline, type V2ActionOptions, type V2AddLiquidityAmounts, type V2ContractReadSpec, type V2FactoryReadOptions, type V2LiquidityAmounts, type V2PairKey, type V2PairState, type V2RemoveLiquidityAmounts, type V2RouterReadOptions, type V2SwapActionOptions, type V2TokenPairAmountInput, V2_FACTORY_READ_SELECTORS, V2_INIT_CODE_HASH, V2_PAIR_READ_SELECTORS, V2_ROUTER_READ_SELECTORS, V2_ROUTER_SELECTORS, ZERO, ZERO_PERCENT, _1000, _997, applyV2SlippageMin, buildV2AddLiquidityAction, buildV2AddLiquidityEthAction, buildV2FactoryFeeToRead, buildV2FactoryPairRead, buildV2LpApproveAction, buildV2PairAllowanceRead, buildV2PairBalanceRead, buildV2PairKLastRead, buildV2PairReservesRead, buildV2PairTotalSupplyRead, buildV2RemoveLiquidityAction, buildV2RemoveLiquidityEthAction, buildV2RouterAllowedTradingPairRead, buildV2RouterAmountsInRead, buildV2RouterAmountsOutRead, buildV2SwapEthForExactTokensAction, buildV2SwapExactEthForTokensAction, buildV2SwapExactTokensForEthAction, buildV2SwapExactTokensForTokensAction, buildV2SwapTokensForExactEthAction, buildV2SwapTokensForExactTokensAction, computePairAddress, computeV2PairAddress, createV2PairKey, evmHexToTronAddress, getV2AddLiquidityMinimums, getV2RemoveLiquidityMinimums, inputOutputComparator, normalizeV2AmountsResult, normalizeV2ReserveResult, quoteV2LiquidityAmount, sortV2Tokens, tradeComparator, tronAddressToEvmHex, tronCreate2Address };