@cronos-labs/rfq-sdk 0.2.3

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

@@ -0,0 +1,144 @@
+import { StaticJsonRpcProvider } from "@ethersproject/providers";
+import { OrderQuoter as OrderQuoterContract, OrderQuoterV4 as OrderQuoterV4Contract, RelayOrderReactor } from "../contracts";
+import { CosignedPriorityOrderInfo, CosignedV2DutchOrderInfo, CosignedV3DutchOrderInfo, DutchOrderInfo, Order, RelayOrder, ResolvedRelayFee, TokenAmount, UniswapXOrder, UnsignedPriorityOrderInfo, UnsignedV2DutchOrderInfo, UnsignedV3DutchOrderInfo } 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 type LegacyOrderInfoTypes = DutchOrderInfo | UnsignedV2DutchOrderInfo | CosignedV2DutchOrderInfo | UnsignedV3DutchOrderInfo | CosignedV3DutchOrderInfo | UnsignedPriorityOrderInfo | CosignedPriorityOrderInfo;
+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;
+}
+/**
+ * V4 resolved order from quoter
+ */
+export interface ResolvedV4Order {
+    input: TokenAmount;
+    outputs: TokenAmount[];
+    auctionResolver: string;
+    witnessTypeString: string;
+}
+/**
+ * V4 order quote result
+ */
+export interface V4OrderQuote {
+    validation: OrderValidation;
+    quote: ResolvedV4Order | undefined;
+    /**
+     * Debug info when `validation !== OK`.
+     * This is the raw revert data returned by multicall (hex string, usually starting with `0x`).
+     */
+    validationErrorData?: string;
+    /**
+     * Best-effort decoded error text (e.g. `Error(string)` / `Panic(uint256)` / custom error selector).
+     */
+    validationErrorText?: string;
+    /**
+     * Optional debug trace of the underlying `eth_call` performed by the quoter.
+     * Captures the JSON-RPC method + params (payload), and the raw RPC result/error (when available).
+     * Present only when `validation !== OK`.
+     */
+    rpcCalls?: V4RpcCallTrace[];
+}
+/**
+ * Signed V4 order (Hybrid orders)
+ */
+export interface SignedV4Order {
+    order: UniswapXOrder;
+    signature: string;
+}
+export type V4RpcCallTrace = {
+    method: string;
+    params: unknown[];
+    result?: unknown;
+    error?: {
+        message?: string;
+        code?: unknown;
+        data?: unknown;
+        body?: unknown;
+        error?: unknown;
+    };
+};
+/**
+ * V4 order quoter for Hybrid orders
+ */
+export declare class V4OrderQuoter implements OrderQuoter<SignedV4Order, V4OrderQuote> {
+    protected provider: StaticJsonRpcProvider;
+    protected chainId: number;
+    protected quoter: OrderQuoterV4Contract;
+    constructor(provider: StaticJsonRpcProvider, chainId: number, orderQuoterAddress?: string);
+    quote(order: SignedV4Order): Promise<V4OrderQuote>;
+    quoteBatch(orders: SignedV4Order[]): Promise<V4OrderQuote[]>;
+    private getValidations;
+    private getMulticallResults;
+    get orderQuoterAddress(): string;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { OrderValidation, RelayOrderQuoter, SignedRelayOrder, SignedUniswapXOrder, SignedV4Order, UniswapXOrderQuoter, V4OrderQuoter } 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[]>;
+}
+/**
+ * V4 order validator for Hybrid orders
+ */
+export declare class V4OrderValidator extends V4OrderQuoter {
+    validate(order: SignedV4Order): Promise<OrderValidation>;
+    validateBatch(orders: SignedV4Order[]): Promise<OrderValidation[]>;
+}

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

@@ -0,0 +1,23 @@
+import { Provider } from "@ethersproject/providers";
+import { ChainId } from "@uniswap/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/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/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,52 @@
+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;
+    /**
+     * Detects V4 order type by checking if the first address is a known resolver
+     * V4 orders are serialized as: (resolver, orderData)
+     */
+    private detectV4OrderType;
+    /**
+     * Parses a V4 order based on its resolver
+     */
+    private parseV4Order;
+    /**
+     * Determine the order type of a UniswapX order
+     * @dev Special cases limit orders which are dutch orders with no output decay
+     * @dev V4 orders (like HybridOrder) are detected by instance check since they use resolver-based lookup
+     */
+    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/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@cronos-labs/rfq-sdk",
+  "version": "0.2.3",
+  "author": "Cronos Labs",
+  "repository": "https://github.com/cronos-labs/rfq-sdk.git",
+  "keywords": [
+    "uniswap",
+    "cronos",
+    "rfq",
+    "trading",
+    "evm",
+    "permit2"
+  ],
+  "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",
+    "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",
+    "@uniswap/permit2-sdk": "^1.2.1",
+    "@uniswap/sdk-core": "^7.5.0",
+    "ethers": "^5.7.0",
+    "tslib": "^2.6.0"
+  },
+  "devDependencies": {
+    "@typechain/ethers-v5": "^10.1.0",
+    "@types/jest": "^24.0.25",
+    "@types/node": "^18.7.16",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.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": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "import": "./dist/esm/src/index.js",
+      "require": "./dist/cjs/src/index.js"
+    }
+  },
+  "sideEffects": false
+}