@juiceswapxyz/uniswapx-sdk 0.1.2-beta.0 → 3.0.0

package/dist/types/src/trade/V3DutchOrderTrade.d.ts

@@ -1,41 +0,0 @@
-import { Currency, CurrencyAmount, Price, TradeType } from "@juiceswapxyz/sdk-core";
-import { UnsignedV3DutchOrder, UnsignedV3DutchOrderInfo } from "../order/V3DutchOrder";
-export declare class V3DutchOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
-    readonly tradeType: TTradeType;
-    readonly order: UnsignedV3DutchOrder;
-    readonly expectedAmounts: {
-        expectedAmountIn: string;
-        expectedAmountOut: string;
-    } | undefined;
-    private _inputAmount;
-    private _outputAmounts;
-    private _currencyIn;
-    private _currenciesOut;
-    constructor({ currencyIn, currenciesOut, orderInfo, tradeType, expectedAmounts, }: {
-        currencyIn: TInput;
-        currenciesOut: TOutput[];
-        orderInfo: UnsignedV3DutchOrderInfo;
-        tradeType: TTradeType;
-        expectedAmounts?: {
-            expectedAmountIn: string;
-            expectedAmountOut: string;
-        };
-    });
-    get inputAmount(): CurrencyAmount<TInput>;
-    get outputAmounts(): CurrencyAmount<TOutput>[];
-    get outputAmount(): CurrencyAmount<TOutput>;
-    minimumAmountOut(): CurrencyAmount<TOutput>;
-    maximumAmountIn(): CurrencyAmount<TInput>;
-    private _executionPrice;
-    /**
-     * The price expressed in terms of output amount/input amount.
-     */
-    get executionPrice(): Price<TInput, TOutput>;
-    /**
-     * Return the execution price after accounting for slippage tolerance
-     * @returns The execution price
-     */
-    worstExecutionPrice(): Price<TInput, TOutput>;
-    private getExpectedAmountIn;
-    private getExpectedAmountOut;
-}

package/dist/types/src/trade/V3DutchOrderTrade.test.d.ts

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

package/dist/types/src/trade/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./DutchOrderTrade";
-export * from "./V2DutchOrderTrade";
-export * from "./PriorityOrderTrade";
-export * from "./RelayOrderTrade";
-export * from "./V3DutchOrderTrade";

package/dist/types/src/trade/utils.d.ts

@@ -1,8 +0,0 @@
-import { Currency } from "@juiceswapxyz/sdk-core";
-export declare enum NativeAssets {
-    MATIC = "MATIC",
-    BNB = "BNB",
-    AVAX = "AVAX",
-    ETH = "ETH"
-}
-export declare function areCurrenciesEqual(currency: Currency, address: string | null, chainId: number): boolean;

package/dist/types/src/utils/EventWatcher.d.ts

@@ -1,46 +0,0 @@
-import { BaseProvider, Log } from "@ethersproject/providers";
-import { BaseContract, BigNumber, Event } from "ethers";
-import { ExclusiveDutchOrderReactor, RelayOrderReactor } from "../contracts";
-import { FillEvent } from "../contracts/DutchOrderReactor";
-export type TokenTransfer = {
-    token: string;
-    amount: BigNumber;
-};
-export interface FillData {
-    orderHash: string;
-    filler: string;
-    nonce: BigNumber;
-    swapper: string;
-}
-export interface FillInfo extends FillData {
-    blockNumber: number;
-    txHash: string;
-    inputs: TokenTransfer[];
-    outputs: TokenTransfer[];
-}
-/**
- * Helper for watching events
- */
-declare abstract class EventWatcher<TReactor extends BaseContract> {
-    protected reactor: TReactor;
-    constructor(reactor: TReactor);
-    abstract getFillLogs(fromBlock: number, toBlock?: number): Promise<FillEvent[]>;
-    abstract onFill(callback: (fillData: FillData, event: Event) => void): void;
-    getFillEvents(fromBlock: number, toBlock?: number): Promise<FillData[]>;
-    getFillInfo(fromBlock: number, toBlock?: number): Promise<FillInfo[]>;
-    getTokenTransfers(logs: Log[], recipient: string): {
-        token: string;
-        amount: BigNumber;
-    }[];
-}
-export declare class UniswapXEventWatcher extends EventWatcher<ExclusiveDutchOrderReactor> {
-    constructor(provider: BaseProvider, reactorAddress: string);
-    getFillLogs(fromBlock: number, toBlock?: number): Promise<FillEvent[]>;
-    onFill(callback: (fillData: FillData, event: Event) => void): void;
-}
-export declare class RelayEventWatcher extends EventWatcher<RelayOrderReactor> {
-    constructor(provider: BaseProvider, reactorAddress: string);
-    getFillLogs(fromBlock: number, toBlock?: number): Promise<FillEvent[]>;
-    onFill(callback: (fillData: FillData, event: Event) => void): void;
-}
-export {};

package/dist/types/src/utils/NonceManager.d.ts

@@ -1,36 +0,0 @@
-import { BaseProvider } from "@ethersproject/providers";
-import { BigNumber } from "ethers";
-/**
- * Helper to track Permit2 nonces for addresses
- */
-export declare class NonceManager {
-    private provider;
-    private permit2;
-    private currentWord;
-    private currentBitmap;
-    constructor(provider: BaseProvider, chainId: number, permit2Address?: string);
-    /**
-     * Finds the next unused nonce and returns it
-     * Marks the nonce as used so it won't be returned again from this instance
-     * NOTE: if any nonce usages are in-flight and created outside of this instance,
-     * this function will not know about them and will return duplicates
-     */
-    useNonce(address: string): Promise<BigNumber>;
-    isUsed(address: string, nonce: BigNumber): Promise<boolean>;
-    private getNextOpenWord;
-}
-interface SplitNonce {
-    word: BigNumber;
-    bitPos: BigNumber;
-}
-export declare function splitNonce(nonce: BigNumber): SplitNonce;
-export declare function buildNonce(word: BigNumber, bitPos: number): BigNumber;
-export declare function getFirstUnsetBit(bitmap: BigNumber): number;
-export declare function setBit(bitmap: BigNumber, bitPos: number): BigNumber;
-interface CancelParams {
-    word: BigNumber;
-    mask: BigNumber;
-}
-export declare function getCancelSingleParams(nonceToCancel: BigNumber): CancelParams;
-export declare function getCancelMultipleParams(noncesToCancel: BigNumber[]): CancelParams[];
-export {};

package/dist/types/src/utils/NonceManager.test.d.ts

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

package/dist/types/src/utils/OrderQuoter.d.ts

@@ -1,79 +0,0 @@
-import { StaticJsonRpcProvider } from "@ethersproject/providers";
-import { OrderQuoter as OrderQuoterContract, RelayOrderReactor } from "../contracts";
-import { Order, RelayOrder, ResolvedRelayFee, TokenAmount, UniswapXOrder } from "../order";
-export declare enum OrderValidation {
-    Expired = 0,
-    NonceUsed = 1,
-    InsufficientFunds = 2,
-    InvalidSignature = 3,
-    InvalidOrderFields = 4,
-    UnknownError = 5,
-    ValidationFailed = 6,
-    ExclusivityPeriod = 7,
-    OrderNotFillableYet = 8,
-    InvalidGasPrice = 9,
-    InvalidCosignature = 10,
-    OK = 11
-}
-export interface ResolvedUniswapXOrder {
-    input: TokenAmount;
-    outputs: TokenAmount[];
-}
-export interface UniswapXOrderQuote {
-    validation: OrderValidation;
-    quote: ResolvedUniswapXOrder | undefined;
-}
-export interface ResolvedRelayOrder {
-    fee: ResolvedRelayFee;
-}
-export interface RelayOrderQuote {
-    validation: OrderValidation;
-    quote: ResolvedRelayOrder | undefined;
-}
-export interface SignedUniswapXOrder {
-    order: UniswapXOrder;
-    signature: string;
-}
-export interface SignedRelayOrder {
-    order: RelayOrder;
-    signature: string;
-}
-export interface SignedOrder {
-    order: Order;
-    signature: string;
-}
-interface OrderQuoter<TOrder, TQuote> {
-    quote(order: TOrder): Promise<TQuote>;
-    quoteBatch(orders: TOrder[]): Promise<TQuote[]>;
-    orderQuoterAddress: string;
-}
-/**
- * UniswapX order quoter
- */
-export declare class UniswapXOrderQuoter implements OrderQuoter<SignedUniswapXOrder, UniswapXOrderQuote> {
-    protected provider: StaticJsonRpcProvider;
-    protected chainId: number;
-    protected quoter: OrderQuoterContract;
-    constructor(provider: StaticJsonRpcProvider, chainId: number, orderQuoterAddress?: string);
-    quote(order: SignedUniswapXOrder): Promise<UniswapXOrderQuote>;
-    quoteBatch(orders: SignedUniswapXOrder[]): Promise<UniswapXOrderQuote[]>;
-    private getValidations;
-    private getMulticallResults;
-    get orderQuoterAddress(): string;
-}
-/**
- * Relay order quoter
- */
-export declare class RelayOrderQuoter implements OrderQuoter<SignedRelayOrder, RelayOrderQuote> {
-    protected provider: StaticJsonRpcProvider;
-    protected chainId: number;
-    protected quoter: RelayOrderReactor;
-    private quoteFunctionSelector;
-    constructor(provider: StaticJsonRpcProvider, chainId: number, reactorAddress?: string);
-    quote(order: SignedRelayOrder): Promise<RelayOrderQuote>;
-    quoteBatch(orders: SignedRelayOrder[]): Promise<RelayOrderQuote[]>;
-    private getMulticallResults;
-    private getValidations;
-    get orderQuoterAddress(): string;
-}
-export {};

package/dist/types/src/utils/OrderValidator.d.ts

@@ -1,12 +0,0 @@
-import { OrderValidation, RelayOrderQuoter, SignedRelayOrder, SignedUniswapXOrder, UniswapXOrderQuoter } from "./OrderQuoter";
-/**
- * UniswapX order validator
- */
-export declare class OrderValidator extends UniswapXOrderQuoter {
-    validate(order: SignedUniswapXOrder): Promise<OrderValidation>;
-    validateBatch(orders: SignedUniswapXOrder[]): Promise<OrderValidation[]>;
-}
-export declare class RelayOrderValidator extends RelayOrderQuoter {
-    validate(order: SignedRelayOrder): Promise<OrderValidation>;
-    validateBatch(orders: SignedRelayOrder[]): Promise<OrderValidation[]>;
-}

package/dist/types/src/utils/PermissionedTokenValidator.d.ts

@@ -1,23 +0,0 @@
-import { Provider } from "@ethersproject/providers";
-import { ChainId } from "@juiceswapxyz/sdk-core";
-import { PERMISSIONED_TOKENS } from "../constants";
-export declare class PermissionedTokenValidator {
-    /**
-     * Checks if a token is a permissioned token
-     * @param tokenAddress The address of the token
-     * @returns True if the token is a permissioned token, false otherwise
-     */
-    static isPermissionedToken(tokenAddress: string, chainId: ChainId, permissionedTokens?: typeof PERMISSIONED_TOKENS): boolean;
-    /**
-     * Checks if a transfer would be allowed for a permissioned token
-     * @param provider The provider to use for the view call
-     * @param tokenAddress The address of the permissioned token
-     * @param from The sender's address
-     * @param to The recipient's address
-     * @param value The amount to transfer (in base units)
-     * @returns True if the token is not a permissioned token or the transfer is
-     * allowed, false otherwise
-     * @throws Will throw an exception if there is an error with the provider
-     */
-    static preTransferCheck(provider: Provider, tokenAddress: string, from: string, to: string, value: string, permissionedTokens?: typeof PERMISSIONED_TOKENS): Promise<boolean>;
-}

package/dist/types/src/utils/dutchBlockDecay.d.ts

@@ -1,15 +0,0 @@
-import { BigNumber } from "ethers";
-import { NonlinearDutchDecay } from "../order";
-declare class NonLinearDutchDecayLib {
-    static decay(curve: NonlinearDutchDecay, startAmount: BigNumber, decayStartBlock: number, currentBlock: number): BigNumber;
-    static linearDecay(startPoint: number, endPoint: number, currentPoint: number, startAmount: BigNumber, endAmount: BigNumber): BigNumber;
-}
-export { NonLinearDutchDecayLib };
-export interface DutchBlockDecayConfig {
-    decayStartBlock: number;
-    startAmount: BigNumber;
-    relativeBlocks: number[];
-    relativeAmounts: bigint[];
-}
-export declare function getBlockDecayedAmount(config: DutchBlockDecayConfig, atBlock: number): BigNumber;
-export declare function getEndAmount(config: Partial<DutchBlockDecayConfig>): BigNumber;

package/dist/types/src/utils/dutchBlockDecay.test.d.ts

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

package/dist/types/src/utils/dutchDecay.d.ts

@@ -1,8 +0,0 @@
-import { BigNumber } from "ethers";
-export interface DutchDecayConfig {
-    startAmount: BigNumber;
-    endAmount: BigNumber;
-    decayStartTime: number;
-    decayEndTime: number;
-}
-export declare function getDecayedAmount(config: DutchDecayConfig, atTime?: number): BigNumber;

package/dist/types/src/utils/dutchDecay.test.d.ts

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

package/dist/types/src/utils/index.d.ts

@@ -1,12 +0,0 @@
-import { OrderType } from "../constants";
-export * from "./OrderValidator";
-export * from "./NonceManager";
-export * from "./OrderQuoter";
-export * from "./EventWatcher";
-export * from "./multicall";
-export * from "./dutchDecay";
-export * from "./order";
-export * from "./PermissionedTokenValidator";
-export declare function stripHexPrefix(a: string): string;
-export declare function getPermit2(chainId: number, permit2Address?: string): string;
-export declare function getReactor(chainId: number, orderType: OrderType, reactorAddress?: string): string;

package/dist/types/src/utils/multicall.d.ts

@@ -1,36 +0,0 @@
-import { Interface } from "@ethersproject/abi";
-import { StaticJsonRpcProvider } from "@ethersproject/providers";
-import { BlockOverrides } from "../order";
-export type MulticallParams = {
-    contractInterface: Interface;
-    functionName: string;
-};
-export type MulticallSameContractParams<TFunctionParams> = MulticallParams & {
-    address: string;
-    functionParams: TFunctionParams[];
-};
-export type MulticallSameFunctionParams<TFunctionParams> = MulticallParams & {
-    addresses: string[];
-    functionParam: TFunctionParams;
-};
-export type MulticallResult = {
-    success: boolean;
-    returnData: string;
-};
-type Call = {
-    target: string;
-    callData: string;
-};
-export declare function multicallSameContractManyFunctions<TFunctionParams extends any[] | undefined>(provider: StaticJsonRpcProvider, params: MulticallSameContractParams<TFunctionParams>, stateOverrrides?: {
-    code?: string;
-    state?: any;
-}, blockOverrides?: BlockOverrides): Promise<MulticallResult[]>;
-export declare function multicallSameFunctionManyContracts<TFunctionParams extends any[] | undefined>(provider: StaticJsonRpcProvider, params: MulticallSameFunctionParams<TFunctionParams>, stateOverrrides?: {
-    code?: string;
-    state?: any;
-}, blockOverrides?: BlockOverrides): Promise<MulticallResult[]>;
-export declare function multicall(provider: StaticJsonRpcProvider, calls: Call[], stateOverrides?: {
-    code?: string;
-    state?: any;
-}, blockOverrides?: BlockOverrides): Promise<MulticallResult[]>;
-export {};

package/dist/types/src/utils/order.d.ts

@@ -1,42 +0,0 @@
-import { BigNumber } from "ethers";
-import { OrderType } from "../constants";
-import { Order, RelayOrder, UniswapXOrder } from "../order";
-declare abstract class OrderParser {
-    abstract orderInfoOffset: number;
-    abstract parseOrder(order: string, chainId: number): Order;
-    /**
-     * Parses a serialized order based on the order shape
-     * @dev called by derived classes which set the offset
-     */
-    protected _parseOrder(order: string): OrderType;
-    /**
-     * Determines the OrderType from an Order object
-     * @return OrderType
-     */
-    getOrderType(order: Order): OrderType;
-    /**
-     * Helper function to determine the OrderType from a serialized order
-     */
-    getOrderTypeFromEncoded(order: string, chainId: number): OrderType;
-}
-export declare class UniswapXOrderParser extends OrderParser {
-    orderInfoOffset: number;
-    /**
-     * Parses a serialized order
-     */
-    parseOrder(order: string, chainId: number): UniswapXOrder;
-    /**
-     * Determine the order type of a UniswapX order
-     * @dev Special cases limit orders which are dutch orders with no output decay
-     */
-    getOrderType(order: Order): OrderType;
-}
-export declare class RelayOrderParser extends OrderParser {
-    orderInfoOffset: number;
-    /**
-     * Parses a serialized order
-     */
-    parseOrder(order: string, chainId: number): RelayOrder;
-}
-export declare function originalIfZero(value: BigNumber, original: BigNumber): BigNumber;
-export {};

package/dist/types/src/utils/order.test.d.ts

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