@juiceswapxyz/uniswapx-sdk 0.0.1-beta.0

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

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

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

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

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

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

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

@@ -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 {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@juiceswapxyz/uniswapx-sdk",
+  "version": "0.0.1-beta.0",
+  "repository": "https://github.com/JuiceSwapxyz/sdk.git",
+  "keywords": [
+    "juiceswap",
+    "ethereum"
+  ],
+  "license": "MIT",
+  "main": "./dist/cjs/src/index.js",
+  "typings": "./dist/types/src/index.d.ts",
+  "module": "./dist/esm/src/index.js",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=10"
+  },
+  "scripts": {
+    "build": "yarn run typechain && yarn build:cjs && yarn build:esm && yarn build:types",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "prettier": "prettier \"src/**/*.ts\" --list-different",
+    "release": "semantic-release",
+    "test": "run-s test:unit test:integration",
+    "test:unit": "jest --testPathPattern src --detectOpenHandles --forceExit --testPathIgnorePatterns dist",
+    "test:integration": "cd integration && yarn && yarn test",
+    "typechain": "typechain --target=ethers-v5 --out-dir src/contracts --glob ./abis/**/*.json"
+  },
+  "dependencies": {
+    "@ethersproject/bytes": "^5.7.0",
+    "@ethersproject/providers": "^5.7.0",
+    "@juiceswapxyz/sdk-core": "0.0.1-beta.0",
+    "@uniswap/permit2-sdk": "^1.2.1",
+    "ethers": "^5.7.0"
+  },
+  "devDependencies": {
+    "@typechain/ethers-v5": "^10.1.0",
+    "@types/jest": "^24.0.25",
+    "@types/node": "^18.7.16",
+    "@typescript-eslint/eslint-plugin": "^5.62",
+    "@typescript-eslint/parser": "^5.62",
+    "eslint": "^7.8.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-functional": "^3.0.2",
+    "eslint-plugin-import": "^2.22.0",
+    "husky": "^8.0.3",
+    "jest": "25.5.0",
+    "jest-environment-node": "25.5.0",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.4.1",
+    "ts-jest": "^25.5.1",
+    "ts-node": "^10.9.1",
+    "typechain": "^8.1.0",
+    "typescript": "^4.3.3"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "yarn fix"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "release": {
+    "extends": "semantic-release-monorepo",
+    "branches": [
+      {
+        "name": "still-in-alpha",
+        "prerelease": false
+      },
+      {
+        "name": "beta",
+        "prerelease": true
+      }
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "angular",
+          "releaseRules": "../../publishing/release-rules.cjs"
+        }
+      ],
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "@semantic-release/exec",
+        {
+          "successCmd": "git restore yarn.lock && yarn",
+          "failCmd": "git restore yarn.lock && yarn",
+          "execCwd": "../.."
+        }
+      ]
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "import": "./dist/esm/src/index.js",
+      "require": "./dist/cjs/src/index.js"
+    }
+  },
+  "sideEffects": false
+}