@cronos-labs/rfq-sdk 0.2.3

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

@@ -0,0 +1,244 @@
+import { BigNumber } from "ethers";
+/**
+ * V4 OrderInfo structure with hooks support
+ * Mirrors mandatory-hook reactor contract
+ */
+export type OrderInfoV4 = {
+    reactor: string;
+    swapper: string;
+    nonce: BigNumber;
+    deadline: number;
+    preExecutionHook: string;
+    preExecutionHookData: string;
+    postExecutionHook: string;
+    postExecutionHookData: string;
+    auctionResolver: string;
+};
+/**
+ * Signed order container for V4
+ * Encoded as: abi.encode(resolver, abi.encode(resolverSpecificOrder))
+ */
+export type SignedOrder = {
+    order: string;
+    sig: string;
+};
+/**
+ * Input token specification
+ */
+export type InputToken = {
+    token: string;
+    amount: BigNumber;
+    maxAmount: BigNumber;
+};
+/**
+ * Output token specification
+ * address(0) for native ETH
+ */
+export type OutputToken = {
+    token: string;
+    amount: BigNumber;
+    recipient: string;
+};
+/**
+ * Resolved order after resolver processes it
+ */
+export type ResolvedOrder = {
+    info: OrderInfoV4;
+    input: InputToken;
+    outputs: OutputToken[];
+    sig: string;
+    hash: string;
+    auctionResolver: string;
+    witnessTypeString: string;
+};
+/**
+ * Hybrid auction input token definition
+ * maxAmount is fixed for exact-in orders
+ */
+export type HybridInput = {
+    token: string;
+    maxAmount: BigNumber;
+};
+/**
+ * Hybrid auction output token definition
+ * minAmount is scaled up for exact-in orders
+ */
+export type HybridOutput = {
+    token: string;
+    minAmount: BigNumber;
+    recipient: string;
+};
+/**
+ * Hybrid cosigner data (optional)
+ */
+export type HybridCosignerData = {
+    auctionTargetBlock: BigNumber;
+    supplementalPriceCurve: BigNumber[];
+    exclusiveFiller: string;
+    exclusivityOverrideBps: BigNumber;
+    exclusivityEndBlock: BigNumber;
+};
+/**
+ * JSON serialization format for HybridCosignerData
+ */
+export type HybridCosignerDataJSON = {
+    auctionTargetBlock: string;
+    supplementalPriceCurve: string[];
+    exclusiveFiller: string;
+    exclusivityOverrideBps: number;
+    exclusivityEndBlock: string;
+};
+export type UnsignedHybridOrderInfo = OrderInfoV4 & {
+    cosigner: string;
+    input: HybridInput;
+    outputs: HybridOutput[];
+    auctionStartBlock: BigNumber;
+    baselinePriorityFee: BigNumber;
+    scalingFactor: BigNumber;
+    priceCurve: BigNumber[];
+};
+export type CosignedHybridOrderInfo = UnsignedHybridOrderInfo & {
+    cosignerData: HybridCosignerData;
+    cosignature: string;
+};
+export type OrderInfoV4JSON = Omit<OrderInfoV4, "nonce"> & {
+    nonce: string;
+};
+export type HybridInputJSON = {
+    token: string;
+    maxAmount: string;
+};
+export type HybridOutputJSON = {
+    token: string;
+    minAmount: string;
+    recipient: string;
+};
+export type UnsignedHybridOrderInfoJSON = Omit<UnsignedHybridOrderInfo, "nonce" | "input" | "outputs" | "auctionStartBlock" | "baselinePriorityFee" | "scalingFactor" | "priceCurve"> & {
+    nonce: string;
+    input: HybridInputJSON;
+    outputs: HybridOutputJSON[];
+    auctionStartBlock: string;
+    baselinePriorityFee: string;
+    scalingFactor: string;
+    priceCurve: string[];
+};
+export type CosignedHybridOrderInfoJSON = UnsignedHybridOrderInfoJSON & {
+    cosignerData: HybridCosignerDataJSON;
+    cosignature: string;
+};
+/**
+ * DCA Intent structure
+ * Signed once by swapper
+ */
+export type DCAIntent = {
+    swapper: string;
+    nonce: BigNumber;
+    chainId: number;
+    hookAddress: string;
+    isExactIn: boolean;
+    inputToken: string;
+    outputToken: string;
+    cosigner: string;
+    minPeriod: BigNumber;
+    maxPeriod: BigNumber;
+    minChunkSize: BigNumber;
+    maxChunkSize: BigNumber;
+    minPrice: BigNumber;
+    deadline: BigNumber;
+    outputAllocations: OutputAllocation[];
+    privateIntent: PrivateIntent;
+};
+/**
+ * Private parameters - Only hash revealed on-chain for privacy
+ */
+export type PrivateIntent = {
+    totalAmount: BigNumber;
+    exactFrequency: BigNumber;
+    numChunks: BigNumber;
+    salt: string;
+    oracleFeeds: FeedInfo[];
+};
+/**
+ * Output distribution specification
+ */
+export type OutputAllocation = {
+    recipient: string;
+    basisPoints: number;
+};
+/**
+ * Oracle feed information
+ */
+export type FeedInfo = {
+    feedId: string;
+    feed_address: string;
+    feedType: string;
+};
+/**
+ * Cosigner authorization for single execution
+ */
+export type DCAOrderCosignerData = {
+    swapper: string;
+    nonce: BigNumber;
+    execAmount: BigNumber;
+    orderNonce: BigNumber;
+    limitAmount: BigNumber;
+};
+/**
+ * On-chain execution state
+ */
+export type DCAExecutionState = {
+    executedChunks: BigNumber;
+    lastExecutionTime: BigNumber;
+    cancelled: boolean;
+    totalInputExecuted: BigNumber;
+    totalOutput: BigNumber;
+};
+/**
+ * Optional Permit2 allowance data
+ */
+export type PermitData = {
+    hasPermit: boolean;
+    permitSingle: {
+        details: {
+            token: string;
+            amount: BigNumber;
+        };
+        spender: string;
+        sigDeadline: BigNumber;
+        nonce: BigNumber;
+    };
+    signature: string;
+};
+/**
+ * JSON serialization format for DCAIntent
+ */
+export type DCAIntentJSON = Omit<DCAIntent, "nonce" | "minPeriod" | "maxPeriod" | "minChunkSize" | "maxChunkSize" | "minPrice" | "deadline" | "privateIntent"> & {
+    nonce: string;
+    minPeriod: string;
+    maxPeriod: string;
+    minChunkSize: string;
+    maxChunkSize: string;
+    minPrice: string;
+    deadline: string;
+    privateIntent: {
+        totalAmount: string;
+        exactFrequency: string;
+        numChunks: string;
+        salt: string;
+        oracleFeeds: FeedInfo[];
+    };
+};
+/**
+ * Resolution options for a HybridOrder when simulating fills
+ */
+export type HybridOrderResolutionOptions = {
+    currentBlock: BigNumber;
+    priorityFeeWei: BigNumber;
+    filler?: string;
+};
+/**
+ * Block overrides for quoting
+ */
+export type BlockOverridesV4 = {
+    number?: string;
+} | undefined;

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

@@ -0,0 +1,24 @@
+import { OrderInfo } from "./types";
+export declare enum ValidationType {
+    None = 0,
+    ExclusiveFiller = 1
+}
+type ExclusiveFillerData = {
+    filler: string;
+    lastExclusiveTimestamp: number;
+};
+export type ValidationInfo = {
+    additionalValidationContract: string;
+    additionalValidationData: string;
+};
+export type CustomOrderValidation = {
+    type: ValidationType.None;
+    data: null;
+} | {
+    type: ValidationType.ExclusiveFiller;
+    data: ExclusiveFillerData;
+};
+export declare function parseValidation(info: OrderInfo): CustomOrderValidation;
+export declare function parseExclusiveFillerData(encoded: string): CustomOrderValidation;
+export declare function encodeExclusiveFillerData(fillerAddress: string, lastExclusiveTimestamp: number, chainId?: number, additionalValidationContractAddress?: string): ValidationInfo;
+export {};

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

@@ -0,0 +1,33 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@uniswap/sdk-core";
+import { DutchOrder, DutchOrderInfo } from "../order";
+export declare class DutchOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: DutchOrder;
+    private _inputAmount;
+    private _outputAmounts;
+    private _currencyIn;
+    private _currenciesOut;
+    constructor({ currencyIn, currenciesOut, orderInfo, tradeType, }: {
+        currencyIn: TInput;
+        currenciesOut: TOutput[];
+        orderInfo: DutchOrderInfo;
+        tradeType: TTradeType;
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmounts(): CurrencyAmount<TOutput>[];
+    private _firstNonFeeOutputStartEndAmounts;
+    private getFirstNonFeeOutputStartEndAmounts;
+    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>;
+}

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

@@ -0,0 +1,61 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@uniswap/sdk-core";
+import { CosignedHybridOrder } from "../order/v4/HybridOrder";
+import { CosignedHybridOrderInfo } from "../order/v4/types";
+export declare class HybridOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: CosignedHybridOrder;
+    readonly expectedAmounts: {
+        expectedAmountIn: string;
+        expectedAmountOut: string;
+    } | undefined;
+    private _inputAmount;
+    private _outputAmounts;
+    private _currencyIn;
+    private _currenciesOut;
+    constructor({ currencyIn, currenciesOut, orderInfo, chainId, resolver, permit2Address, tradeType, expectedAmounts, }: {
+        currencyIn: TInput;
+        currenciesOut: TOutput[];
+        orderInfo: CosignedHybridOrderInfo;
+        chainId: number;
+        resolver: string;
+        permit2Address?: string;
+        tradeType: TTradeType;
+        expectedAmounts?: {
+            expectedAmountIn: string;
+            expectedAmountOut: string;
+        };
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmounts(): CurrencyAmount<TOutput>[];
+    get outputAmount(): CurrencyAmount<TOutput>;
+    /**
+     * For exact-in orders: minimum amount out is the minAmount from the order
+     * For exact-out orders: minimum amount out is the fixed output amount
+     */
+    minimumAmountOut(): CurrencyAmount<TOutput>;
+    /**
+     * For exact-in orders: maximum amount in is the fixed maxAmount
+     * For exact-out orders: maximum amount in is the maxAmount (worst case)
+     */
+    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 worst execution price (max in / min out)
+     */
+    worstExecutionPrice(): Price<TInput, TOutput>;
+    /**
+     * Determine if this is an exact-in order based on the scalingFactor
+     */
+    isExactIn(): boolean;
+    /**
+     * Determine if this is an exact-out order based on the scalingFactor
+     */
+    isExactOut(): boolean;
+    private getExpectedAmountIn;
+    private getExpectedAmountOut;
+}

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

@@ -0,0 +1,43 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@uniswap/sdk-core";
+import { UnsignedPriorityOrder, UnsignedPriorityOrderInfo } from "../order";
+export declare class PriorityOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: UnsignedPriorityOrder;
+    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: UnsignedPriorityOrderInfo;
+        tradeType: TTradeType;
+        expectedAmounts?: {
+            expectedAmountIn: string;
+            expectedAmountOut: string;
+        };
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmounts(): CurrencyAmount<TOutput>[];
+    private _firstNonFeeOutputAmount;
+    private getFirstNonFeeOutputAmount;
+    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/RelayOrderTrade.d.ts

@@ -0,0 +1,34 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@uniswap/sdk-core";
+import { RelayOrder, RelayOrderInfo } from "../order";
+export declare class RelayOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: RelayOrder;
+    private _outputAmount;
+    private _currenciesIn;
+    constructor({ currenciesIn, outputAmount, orderInfo, tradeType, }: {
+        currenciesIn: TInput[];
+        outputAmount: CurrencyAmount<TOutput>;
+        orderInfo: RelayOrderInfo;
+        tradeType: TTradeType;
+    });
+    get outputAmount(): CurrencyAmount<TOutput>;
+    private _feeStartEndAmounts;
+    private _inputAmount;
+    private getFeeInputStartEndAmounts;
+    private getInputAmount;
+    get amountIn(): CurrencyAmount<TInput>;
+    get amountInFee(): CurrencyAmount<TInput>;
+    get maximumAmountInFee(): CurrencyAmount<TInput>;
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     * @dev this only takes into account non fee inputs (does not include gas)
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @dev this only takes into account non fee inputs (does not include gas)
+     * @returns The execution price
+     */
+    worstExecutionPrice(): Price<TInput, TOutput>;
+}

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

@@ -0,0 +1,33 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@uniswap/sdk-core";
+import { UnsignedV2DutchOrder, UnsignedV2DutchOrderInfo } from "../order";
+export declare class V2DutchOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: UnsignedV2DutchOrder;
+    private _inputAmount;
+    private _outputAmounts;
+    private _currencyIn;
+    private _currenciesOut;
+    constructor({ currencyIn, currenciesOut, orderInfo, tradeType, }: {
+        currencyIn: TInput;
+        currenciesOut: TOutput[];
+        orderInfo: UnsignedV2DutchOrderInfo;
+        tradeType: TTradeType;
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmounts(): CurrencyAmount<TOutput>[];
+    private _firstNonFeeOutputStartEndAmounts;
+    private getFirstNonFeeOutputStartEndAmounts;
+    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>;
+}

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

@@ -0,0 +1,41 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@uniswap/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/index.d.ts

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

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

@@ -0,0 +1,8 @@
+import { Currency } from "@uniswap/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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,36 @@
+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 {};