@imtbl/dex-sdk 2.0.0-alpha.0

package/dist/types/contracts/types/factories/WIMX__factory.d.ts

@@ -0,0 +1,219 @@
+import { type ContractRunner } from "ethers";
+import type { WIMX, WIMXInterface } from "../WIMX";
+export declare class WIMX__factory {
+    static readonly abi: readonly [{
+        readonly constant: true;
+        readonly inputs: readonly [];
+        readonly name: "name";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly constant: false;
+        readonly inputs: readonly [{
+            readonly name: "guy";
+            readonly type: "address";
+        }, {
+            readonly name: "wad";
+            readonly type: "uint256";
+        }];
+        readonly name: "approve";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly constant: true;
+        readonly inputs: readonly [];
+        readonly name: "totalSupply";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly constant: false;
+        readonly inputs: readonly [{
+            readonly name: "src";
+            readonly type: "address";
+        }, {
+            readonly name: "dst";
+            readonly type: "address";
+        }, {
+            readonly name: "wad";
+            readonly type: "uint256";
+        }];
+        readonly name: "transferFrom";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly constant: false;
+        readonly inputs: readonly [{
+            readonly name: "wad";
+            readonly type: "uint256";
+        }];
+        readonly name: "withdraw";
+        readonly outputs: readonly [];
+        readonly payable: false;
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly constant: true;
+        readonly inputs: readonly [];
+        readonly name: "decimals";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "uint8";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly constant: true;
+        readonly inputs: readonly [{
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly name: "balanceOf";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly constant: true;
+        readonly inputs: readonly [];
+        readonly name: "symbol";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly constant: false;
+        readonly inputs: readonly [{
+            readonly name: "dst";
+            readonly type: "address";
+        }, {
+            readonly name: "wad";
+            readonly type: "uint256";
+        }];
+        readonly name: "transfer";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly constant: false;
+        readonly inputs: readonly [];
+        readonly name: "deposit";
+        readonly outputs: readonly [];
+        readonly payable: true;
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly constant: true;
+        readonly inputs: readonly [{
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly name: "allowance";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly payable: false;
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly payable: true;
+        readonly stateMutability: "payable";
+        readonly type: "fallback";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "src";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly name: "guy";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "wad";
+            readonly type: "uint256";
+        }];
+        readonly name: "Approval";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "src";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly name: "dst";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "wad";
+            readonly type: "uint256";
+        }];
+        readonly name: "Transfer";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "dst";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "wad";
+            readonly type: "uint256";
+        }];
+        readonly name: "Deposit";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "src";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "wad";
+            readonly type: "uint256";
+        }];
+        readonly name: "Withdrawal";
+        readonly type: "event";
+    }];
+    static createInterface(): WIMXInterface;
+    static connect(address: string, runner?: ContractRunner | null): WIMX;
+}

package/dist/types/contracts/types/factories/index.d.ts

@@ -0,0 +1,6 @@
+export { ERC20__factory } from "./ERC20__factory";
+export { ImmutableSwapProxy__factory } from "./ImmutableSwapProxy__factory";
+export { Multicall__factory } from "./Multicall__factory";
+export { QuoterV2__factory } from "./QuoterV2__factory";
+export { UniswapV3Pool__factory } from "./UniswapV3Pool__factory";
+export { WIMX__factory } from "./WIMX__factory";

package/dist/types/contracts/types/index.d.ts

@@ -0,0 +1,13 @@
+export type { ERC20 } from "./ERC20";
+export type { ImmutableSwapProxy } from "./ImmutableSwapProxy";
+export type { Multicall } from "./Multicall";
+export type { QuoterV2 } from "./QuoterV2";
+export type { UniswapV3Pool } from "./UniswapV3Pool";
+export type { WIMX } from "./WIMX";
+export * as factories from "./factories";
+export { ERC20__factory } from "./factories/ERC20__factory";
+export { ImmutableSwapProxy__factory } from "./factories/ImmutableSwapProxy__factory";
+export { Multicall__factory } from "./factories/Multicall__factory";
+export { QuoterV2__factory } from "./factories/QuoterV2__factory";
+export { UniswapV3Pool__factory } from "./factories/UniswapV3Pool__factory";
+export { WIMX__factory } from "./factories/WIMX__factory";

package/dist/types/errors/exchangeError.d.ts

@@ -0,0 +1,61 @@
+import { Environment } from '@imtbl/config';
+/**
+ * @enum {string} Errors that can be returned by the Exchange.
+ */
+export declare enum ExchangeErrorCode {
+    INVALID_CONFIGURATION = "INVALID_CONFIGURATION",
+    INVALID_SLIPPAGE = "INVALID_SLIPPAGE",
+    INVALID_MAX_HOPS = "INVALID_MAX_HOPS",
+    INVALID_ADDRESS = "INVALID_ADDRESS",
+    DUPLICATE_ADDRESSES = "DUPLICATE_ADDRESSES",
+    CHAIN_NOT_SUPPORTED = "CHAIN_NOT_SUPPORTED",
+    NO_ROUTES_AVAILABLE = "NO_ROUTES_AVAILABLE",
+    PROVIDER_CALL_ERROR = "PROVIDER_CALL_ERROR",
+    APPROVE_ERROR = "APPROVE_ERROR",
+    ALREADY_APPROVED_ERROR = "ALREADY_APPROVED_ERROR"
+}
+/**
+ * The type signature for an error.
+ * Contains a type that corresponds to a {@link ExchangeError} and an optional message string.
+ */
+export type ExchangeErrorType = {
+    type: ExchangeError;
+    message: string;
+};
+/**
+ * The {@link ExchangeError} error class that extends the {@link Error} class.
+ * Contains a message string and a type that corresponds to an {@link ExchangeErrorCode}.
+ * It has a constructor that takes in a message string and a type.
+ */
+export declare class ExchangeError extends Error {
+    message: string;
+    code: ExchangeErrorCode;
+    constructor(message: string, code: ExchangeErrorCode);
+}
+export declare class InvalidConfigurationError extends ExchangeError {
+    constructor(message?: string);
+}
+export declare class ChainNotSupportedError extends ExchangeError {
+    constructor(chain: number, environment: Environment);
+}
+export declare class InvalidSlippageError extends ExchangeError {
+    constructor(message: string);
+}
+export declare class InvalidMaxHopsError extends ExchangeError {
+    constructor(message: string);
+}
+export declare class InvalidAddressError extends ExchangeError {
+    constructor(message: string);
+}
+export declare class DuplicateAddressesError extends ExchangeError {
+    constructor();
+}
+export declare class NoRoutesAvailableError extends ExchangeError {
+    constructor();
+}
+export declare class ProviderCallError extends ExchangeError {
+    constructor(message: string);
+}
+export declare class ApproveError extends ExchangeError {
+    constructor(message: string);
+}

package/dist/types/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './exchangeError';

package/dist/types/exchange.d.ts

@@ -0,0 +1,50 @@
+import { BigNumberish } from 'ethers';
+import { ExchangeModuleConfiguration, TransactionResponse } from './types';
+export declare class Exchange {
+    private provider;
+    private batchProvider;
+    private router;
+    private chainId;
+    private nativeToken;
+    private wrappedNativeToken;
+    private secondaryFees;
+    private nativeTokenService;
+    private swapProxyContractAddress;
+    private routerContractAddress;
+    constructor(configuration: ExchangeModuleConfiguration);
+    private static validate;
+    private getSecondaryFees;
+    private parseTokenLiteral;
+    private getUnwrapTransaction;
+    private getWrapTransaction;
+    private getUnsignedWrapUnwrapTx;
+    private getUnsignedSwapTx;
+    /**
+     * Get the unsigned swap transaction given the amount to sell.
+     * Includes quote details for the swap.
+     *
+     * @param {string} fromAddress The public address that will sign and submit the transaction
+     * @param {string} tokenInAddress Token address or 'native' to sell
+     * @param {string} tokenOutAddress Token address or 'native' to buy
+     * @param {ethers.BigNumberish} amountIn Amount to sell in the smallest unit of the token-in
+     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0
+     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2
+     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes
+     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap
+     */
+    getUnsignedSwapTxFromAmountIn(fromAddress: string, tokenInAddress: string, tokenOutAddress: string, amountIn: BigNumberish, slippagePercent?: number, maxHops?: number, deadline?: number): Promise<TransactionResponse>;
+    /**
+     * Get the unsigned swap transaction given the amount to buy.
+     * Includes quote details for the swap.
+     *
+     * @param {string} fromAddress The public address that will sign and submit the transaction
+     * @param {string} tokenInAddress ERC20 contract address or 'native' to sell
+     * @param {string} tokenOutAddress ERC20 contract address or 'native' to buy
+     * @param {ethers.BigNumberish} amountOut Amount to buy in the smallest unit of the token-out
+     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0
+     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2
+     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes
+     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap
+     */
+    getUnsignedSwapTxFromAmountOut(fromAddress: string, tokenInAddress: string, tokenOutAddress: string, amountOut: BigNumberish, slippagePercent?: number, maxHops?: number, deadline?: number): Promise<TransactionResponse>;
+}

package/dist/types/exchange.getUnsignedSwapTxFromAmountIn.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/exchange.getUnsignedSwapTxFromAmountOut.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/exchange.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './exchange';
+export * from './types';
+export * from './constants';
+export * from './config';

package/dist/types/lib/fees.d.ts

@@ -0,0 +1,16 @@
+import { Coin, CoinAmount, SecondaryFee } from '../types';
+export declare class Fees {
+    private secondaryFees;
+    private amount;
+    constructor(secondaryFees: SecondaryFee[], token: Coin);
+    get token(): Coin;
+    addAmount(amount: CoinAmount<Coin>): void;
+    amountWithFeesApplied(): CoinAmount<Coin>;
+    amountLessFees(): CoinAmount<Coin>;
+    withAmounts(): {
+        amount: CoinAmount<Coin>;
+        recipient: string;
+        basisPoints: number;
+    }[];
+    private total;
+}

package/dist/types/lib/fees.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/getQuotesForRoutes.d.ts

@@ -0,0 +1,14 @@
+import { Route } from '@uniswap/v3-sdk';
+import { TradeType, Token } from '@uniswap/sdk-core';
+import { CoinAmount, ERC20 } from '../types';
+export interface Provider {
+    send: (method: string, params: any[]) => Promise<string>;
+}
+export type QuoteResult = {
+    route: Route<Token, Token>;
+    gasEstimate: bigint;
+    amountIn: CoinAmount<ERC20>;
+    amountOut: CoinAmount<ERC20>;
+    tradeType: TradeType;
+};
+export declare function getQuotesForRoutes(provider: Provider, quoterContractAddress: string, routes: Route<Token, Token>[], amountSpecified: CoinAmount<ERC20>, tradeType: TradeType): Promise<QuoteResult[]>;

package/dist/types/lib/getQuotesForRoutes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './multicall';
+export * from './router';
+export * from './utils';

package/dist/types/lib/multicall.d.ts

@@ -0,0 +1,12 @@
+import { Multicall, UniswapInterfaceMulticall } from '../contracts/types/Multicall';
+type Address = string;
+export type SingleContractCallOptions = {
+    gasRequired: number;
+};
+export type MulticallResponse = {
+    blockNumber: bigint;
+    returnData: UniswapInterfaceMulticall.ResultStructOutput[];
+};
+export declare function multicallSingleCallDataMultipleContracts(multicallContract: Multicall, functionName: string, addresses: Address[]): Promise<MulticallResponse>;
+export declare function multicallMultipleCallDataSingContract(multicallContract: Multicall, calldata: string[], address: Address, options?: SingleContractCallOptions): Promise<MulticallResponse>;
+export {};

package/dist/types/lib/multicall.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/nativeTokenService.d.ts

@@ -0,0 +1,13 @@
+import { Coin, CoinAmount, ERC20, Native } from '../types';
+export declare const canUnwrapToken: (token: Coin) => token is Native;
+export declare class NativeTokenService {
+    readonly nativeToken: Native;
+    readonly wrappedToken: ERC20;
+    constructor(nativeToken: Native, wrappedToken: ERC20);
+    wrapAmount(amount: CoinAmount<Native>): CoinAmount<ERC20>;
+    unwrapAmount(amount: CoinAmount<ERC20>): CoinAmount<Coin>;
+    maybeWrapToken(token: Coin): ERC20;
+    maybeWrapAmount(amount: CoinAmount<Coin>): CoinAmount<ERC20>;
+    private isWrappedNative;
+    isWrapOrUnwrap(tokenIn: Coin, tokenOut: Coin): boolean;
+}

package/dist/types/lib/nativeTokenService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/poolUtils/computePoolAddress.d.ts

@@ -0,0 +1,9 @@
+import { FeeAmount } from '@uniswap/v3-sdk';
+import { ERC20Pair } from './generateERC20Pairs';
+export declare function computePoolAddress({ factoryAddress, erc20Pair, fee, initCodeHashManualOverride, }: {
+    factoryAddress: string;
+    erc20Pair: ERC20Pair;
+    fee: FeeAmount;
+    initCodeHashManualOverride?: string;
+}): string;
+export declare const ensureCorrectERC20AddressOrder: (erc20Pair: ERC20Pair) => ERC20Pair;

package/dist/types/lib/poolUtils/ensureCorrectERC20AddressOrder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/poolUtils/fetchValidPools.d.ts

@@ -0,0 +1,14 @@
+import { Pool } from '@uniswap/v3-sdk';
+import { ERC20 } from '../../types';
+import { ERC20Pair } from './generateERC20Pairs';
+import { Multicall } from '../../contracts/types';
+export type Slot0 = {
+    sqrtPriceX96: bigint;
+    tick: number;
+    observationIndex: number;
+    observationCardinality: number;
+    observationCardinalityNext: number;
+    feeProtocol: number;
+    unlocked: boolean;
+};
+export declare const fetchValidPools: (multicallContract: Multicall, erc20Pair: ERC20Pair, commonRoutingERC20s: ERC20[], factoryAddress: string) => Promise<Pool[]>;

package/dist/types/lib/poolUtils/fetchValidPools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/poolUtils/generateAllAcyclicPaths.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/poolUtils/generateERC20Pairs.d.ts

@@ -0,0 +1,7 @@
+import { ERC20 } from '../../types';
+export type Provider = {
+    chainId: number;
+};
+export type ERC20Pairs = ERC20Pair[];
+export type ERC20Pair = [ERC20, ERC20];
+export declare const generateERC20Pairs: (erc20Pair: ERC20Pair, commonRoutingERC20s: ERC20[]) => ERC20Pairs;

package/dist/types/lib/poolUtils/generateERC20Pairs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/poolUtils/generatePossiblePoolsFromERC20Pairs.d.ts

@@ -0,0 +1,11 @@
+import { FeeAmount } from '@uniswap/v3-sdk';
+import { ERC20 } from '../../types';
+import { ERC20Pair } from './generateERC20Pairs';
+type PoolIDs = PoolID[];
+type PoolID = {
+    erc20Pair: ERC20Pair;
+    fee: FeeAmount;
+    poolAddress: string;
+};
+export declare const generatePossiblePoolsFromERC20Pair: (erc20Pair: ERC20Pair, commonRoutingERC20s: ERC20[], factoryAddress: string) => PoolIDs;
+export {};

package/dist/types/lib/poolUtils/generatePossiblePoolsFromERC20Pairs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/router.d.ts

@@ -0,0 +1,24 @@
+import { Token, TradeType } from '@uniswap/sdk-core';
+import { Pool, Route } from '@uniswap/v3-sdk';
+import { JsonRpcProvider } from 'ethers';
+import { CoinAmount, ERC20 } from '../types';
+import { QuoteResult } from './getQuotesForRoutes';
+import type { Multicall } from '../contracts/types';
+export type RoutingContracts = {
+    multicall: string;
+    coreFactory: string;
+    quoter: string;
+};
+export declare class Router {
+    provider: JsonRpcProvider;
+    multicallContract: Multicall;
+    routingTokens: ERC20[];
+    routingContracts: RoutingContracts;
+    constructor(provider: JsonRpcProvider, multicallContract: Multicall, routingTokens: ERC20[], routingContracts: RoutingContracts);
+    findOptimalRoute(amountSpecified: CoinAmount<ERC20>, otherToken: ERC20, tradeType: TradeType, maxHops?: number): Promise<QuoteResult>;
+    private getBestQuoteFromRoutes;
+    private bestQuoteForAmountIn;
+    private bestQuoteForAmountOut;
+    private determineERC20InAndERC20Out;
+}
+export declare const generateAllAcyclicPaths: (tokenIn: ERC20, tokenOut: ERC20, pools: Pool[], maxHops: number, currentRoute?: Pool[], routes?: Route<Token, Token>[], startTokenIn?: ERC20) => Route<Token, Token>[];

package/dist/types/lib/router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/transactionUtils/approval.d.ts

@@ -0,0 +1,25 @@
+import { TradeType } from '@uniswap/sdk-core';
+import { JsonRpcProvider, TransactionRequest } from 'ethers';
+import { CoinAmount, Coin, ERC20, Native, SecondaryFee, TransactionDetails } from '../../types';
+type PreparedApproval = {
+    spender: string;
+    amount: CoinAmount<ERC20>;
+};
+export declare const prepareApproval: (tradeType: TradeType, userSpecifiedAmount: CoinAmount<Coin>, quotedAmountWithSlippage: CoinAmount<Coin>, contracts: {
+    routerAddress: string;
+    secondaryFeeAddress: string;
+}, secondaryFees: SecondaryFee[]) => PreparedApproval | null;
+/**
+ * Get an unsigned approval transaction if needed
+ *
+ * @param provider The provider to use for the call
+ * @param ownerAddress The address of the owner of the token
+ * @param tokenAddress The address of the token to approve
+ * @param tokenAmount The amount of the token to approve
+ * @param spenderAddress The address of the spender
+ * @returns The unsigned ERC20 approve transaction, or null if no approval is needed
+ */
+export declare const getApproveTransaction: (provider: JsonRpcProvider, ownerAddress: string, tokenAmount: CoinAmount<ERC20>, spenderAddress: string) => Promise<TransactionRequest | null>;
+export declare function getApproveGasEstimate(provider: JsonRpcProvider, ownerAddress: string, spenderAddress: string, tokenAddress: string): Promise<bigint>;
+export declare const getApproval: (provider: JsonRpcProvider, ownerAddress: string, preparedApproval: PreparedApproval, gasPrice: CoinAmount<Native> | null) => Promise<TransactionDetails | null>;
+export {};

package/dist/types/lib/transactionUtils/approval.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/transactionUtils/gas.d.ts

@@ -0,0 +1,18 @@
+import { JsonRpcProvider } from 'ethers';
+import { CoinAmount, Native } from '../../types';
+/**
+ * Fetch the current gas price estimate. Supports both EIP-1559 and non-EIP1559 chains
+ * @param {JsonRpcProvider} provider - The JSON RPC provider used to fetch fee data
+ * @param {Native} nativeToken - The native token of the chain. Gas prices will be denominated in this token
+ * @returns {CoinAmount<Native> | null} - The gas price in the smallest denomination of the chain's currency,
+ *  or null if no gas price is available
+ */
+export declare const fetchGasPrice: (provider: JsonRpcProvider, nativeToken: Native) => Promise<CoinAmount<Native> | null>;
+/**
+ * Calculate the gas fee from the gas price and gas units used for the transaction
+ *
+ * @param {CoinAmount<Native>} gasPrice - The price of gas
+ * @param {BigNumber} gasEstimate - The total gas units that will be used for the transaction
+ * @returns - The cost of the transaction in the gas token's smallest denomination (e.g. WEI)
+ */
+export declare const calculateGasFee: (hasSecondaryFees: boolean, gasPrice: CoinAmount<Native>, gasEstimate: bigint) => CoinAmount<Native>;

package/dist/types/lib/transactionUtils/gas.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/transactionUtils/getQuote.d.ts

@@ -0,0 +1,13 @@
+import { TradeType } from '@uniswap/sdk-core';
+import { Fees } from '../fees';
+import { QuoteResult } from '../getQuotesForRoutes';
+import { NativeTokenService } from '../nativeTokenService';
+import { Coin, CoinAmount, ERC20 } from '../../types';
+export declare function getQuoteAmountFromTradeType(routerQuote: QuoteResult): CoinAmount<ERC20>;
+export declare function applySlippage(tradeType: TradeType, amount: bigint, slippage: number): bigint;
+export declare const prepareUserQuote: (nativeTokenService: NativeTokenService, routerQuote: QuoteResult, slippage: number, tokenOfQuotedAmount: Coin) => {
+    quotedAmount: CoinAmount<Coin>;
+    quotedAmountWithMaxSlippage: CoinAmount<Coin>;
+};
+export declare function getOurQuoteReqAmount(amountSpecified: CoinAmount<Coin>, // the amount specified by the user, either exactIn or exactOut
+fees: Fees, tradeType: TradeType, nativeTokenService: NativeTokenService): CoinAmount<ERC20>;

package/dist/types/lib/transactionUtils/getQuote.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/transactionUtils/slippage.d.ts

@@ -0,0 +1,2 @@
+import { Percent } from '@uniswap/sdk-core';
+export declare const slippageToFraction: (slippage: number) => Percent;

package/dist/types/lib/transactionUtils/slippage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/transactionUtils/swap.d.ts

@@ -0,0 +1,16 @@
+import { Fees } from '../fees';
+import { QuoteResult } from '../getQuotesForRoutes';
+import { NativeTokenService } from '../nativeTokenService';
+import { Coin, CoinAmount, Native, SecondaryFee, TransactionDetails } from '../../types';
+export declare function getSwap(tokenIn: Coin, tokenOut: Coin, adjustedQuote: QuoteResult, fromAddress: string, slippage: number, deadline: number, routerContractAddress: string, secondaryFeesContractAddress: string, gasPrice: CoinAmount<Native> | null, secondaryFees: SecondaryFee[]): TransactionDetails;
+/**
+ * adjustQuoteWithFees adjusts the amountIn of the quote to account for fees
+ * EXACT_OUTPUT swaps will have the fees added to the amountIn if there are fees specified
+ * EXACT_INPUT swaps will have amountIn set to the user-specified amount
+ * @param ourQuote The quote from calling the Quoter contract
+ * @param amountSpecified The user-specified amount for the swap (EXACT...)
+ * @param fees The fees applied to the swap
+ * @param tokenWrapper Helper class for the native token and associated ERC20
+ * @returns {QuoteResult} The adjusted quote
+ */
+export declare function adjustQuoteWithFees(ourQuote: QuoteResult, amountSpecified: CoinAmount<Coin>, fees: Fees, nativeTokenService: NativeTokenService): QuoteResult;

package/dist/types/lib/transactionUtils/swap.test.d.ts

@@ -0,0 +1 @@
+export {};