@cronos-labs/rfq-sdk 0.2.3

package/dist/esm/src/utils/PermissionedTokenValidator.js

@@ -0,0 +1,66 @@
+import { __awaiter } from "tslib";
+import { PERMISSIONED_TOKENS, PermissionedTokenInterface } from "../constants";
+import { PermissionedTokenProxyType } from "../constants";
+import { DSTokenInterface__factory, ISuperstateTokenV4__factory, Proxy__factory } from "../contracts";
+export 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, chainId, permissionedTokens = PERMISSIONED_TOKENS) {
+        return permissionedTokens.some(token => token.address.toLowerCase() === tokenAddress.toLowerCase() && token.chainId === chainId);
+    }
+    /**
+     * 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, tokenAddress, from, to, value, permissionedTokens = PERMISSIONED_TOKENS) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = permissionedTokens.find(token => token.address.toLowerCase() === tokenAddress.toLowerCase());
+            // If the token is not in the list, we don't need to check anything
+            if (!token) {
+                return true;
+            }
+            // Get the resolved token contract
+            let resolvedTokenAddress = tokenAddress;
+            if (token.proxyType === PermissionedTokenProxyType.Standard) {
+                const proxyContract = Proxy__factory.connect(tokenAddress, provider);
+                resolvedTokenAddress = yield proxyContract.target();
+            }
+            else if (token.proxyType === PermissionedTokenProxyType.ERC1967) {
+                // EIP-1967 implementation slot: bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
+                // https://eips.ethereum.org/EIPS/eip-1967
+                const implSlot = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc';
+                const implStorage = yield provider.getStorageAt(tokenAddress, implSlot);
+                resolvedTokenAddress = '0x' + implStorage.slice(26);
+            }
+            // Use the appropriate interface to perform the approval check
+            if (token.interface === PermissionedTokenInterface.DSTokenInterface) {
+                const tokenContract = DSTokenInterface__factory.connect(resolvedTokenAddress, provider);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const [code, _reason] = yield tokenContract.preTransferCheck(from, to, value);
+                return code.toNumber() === 0;
+            }
+            else if (token.interface === PermissionedTokenInterface.ISuperstateTokenV4) {
+                const tokenContract = ISuperstateTokenV4__factory.connect(resolvedTokenAddress, provider);
+                const [fromAllowed, toAllowed] = yield Promise.all([
+                    tokenContract.isAllowed(from),
+                    tokenContract.isAllowed(to),
+                ]);
+                return fromAllowed && toAllowed;
+            }
+            else {
+                throw new Error("Unknown token interface: " + token.interface);
+            }
+        });
+    }
+}
+//# sourceMappingURL=PermissionedTokenValidator.js.map

package/dist/esm/src/utils/PermissionedTokenValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissionedTokenValidator.js","sourceRoot":"","sources":["../../../../src/utils/PermissionedTokenValidator.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAoB,yBAAyB,EAAE,2BAA2B,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAExH,MAAM,OAAO,0BAA0B;IAErC;;;;OAIG;IACH,MAAM,CAAC,mBAAmB,CACxB,YAAoB,EACpB,OAAgB,EAChB,qBAAiD,mBAAmB;QAEpE,OAAO,kBAAkB,CAAC,IAAI,CAC5B,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,YAAY,CAAC,WAAW,EAAE,IAAI,KAAK,CAAC,OAAO,KAAK,OAAO,CACjG,CAAC;IACJ,CAAC;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAO,gBAAgB,CAC3B,QAAkB,EAClB,YAAoB,EACpB,IAAY,EACZ,EAAU,EACV,KAAa,EACb,qBAAiD,mBAAmB;;YAEpE,MAAM,KAAK,GAAG,kBAAkB,CAAC,IAAI,CACnC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,YAAY,CAAC,WAAW,EAAE,CACpE,CAAC;YACF,mEAAmE;YACnE,IAAI,CAAC,KAAK,EAAE;gBACV,OAAO,IAAI,CAAC;aACb;YAED,kCAAkC;YAClC,IAAI,oBAAoB,GAAG,YAAY,CAAC;YACxC,IAAI,KAAK,CAAC,SAAS,KAAK,0BAA0B,CAAC,QAAQ,EAAE;gBAC3D,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;gBACrE,oBAAoB,GAAG,MAAM,aAAa,CAAC,MAAM,EAAE,CAAC;aACrD;iBACI,IAAI,KAAK,CAAC,SAAS,KAAK,0BAA0B,CAAC,OAAO,EAAE;gBAC/D,gGAAgG;gBAChG,0CAA0C;gBAC1C,MAAM,QAAQ,GACZ,oEAAoE,CAAC;gBACvE,MAAM,WAAW,GAAG,MAAM,QAAQ,CAAC,YAAY,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;gBACxE,oBAAoB,GAAG,IAAI,GAAG,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;aACrD;YAED,8DAA8D;YAC9D,IAAI,KAAK,CAAC,SAAS,KAAK,0BAA0B,CAAC,gBAAgB,EAAE;gBACnE,MAAM,aAAa,GAAqB,yBAAyB,CAAC,OAAO,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;gBAC1G,6DAA6D;gBAC7D,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;gBAC9E,OAAO,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;aAC9B;iBACI,IAAI,KAAK,CAAC,SAAS,KAAK,0BAA0B,CAAC,kBAAkB,EAAE;gBAC1E,MAAM,aAAa,GAAG,2BAA2B,CAAC,OAAO,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;gBAC1F,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;oBACjD,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC;oBAC7B,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC;iBAC5B,CAAC,CAAC;gBACH,OAAO,WAAW,IAAI,SAAS,CAAC;aACjC;iBACI;gBACH,MAAM,IAAI,KAAK,CAAC,2BAA2B,GAAG,KAAK,CAAC,SAAS,CAAC,CAAA;aAC/D;QACH,CAAC;KAAA;CACF"}

package/dist/esm/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/esm/src/utils/dutchBlockDecay.js

@@ -0,0 +1,68 @@
+import { BigNumber } from "ethers";
+/*
+These functions mimic the smart contract functions as closely as possible to ensure that the same results are produced.
+Essentially Solidity translated to TypeScript.
+*/
+function locateArrayPosition(curve, currentRelativeBlock) {
+    const relativeBlocks = curve.relativeBlocks;
+    let prev = 0;
+    let next = 0;
+    for (; next < relativeBlocks.length; next++) {
+        if (relativeBlocks[next] >= currentRelativeBlock) {
+            return [prev, next];
+        }
+        prev = next;
+    }
+    return [next - 1, next - 1];
+}
+class NonLinearDutchDecayLib {
+    static decay(curve, startAmount, decayStartBlock, currentBlock) {
+        // mismatch of relativeAmounts and relativeBlocks
+        if (curve.relativeAmounts.length > 16) {
+            throw new Error("InvalidDecayCurve");
+        }
+        // handle current block before decay or no decay
+        if (decayStartBlock >= currentBlock || curve.relativeAmounts.length === 0) {
+            return startAmount;
+        }
+        const blockDelta = currentBlock - decayStartBlock;
+        // Special case for when we need to use the decayStartBlock (0)
+        if (curve.relativeBlocks[0] > blockDelta) {
+            return this.linearDecay(0, curve.relativeBlocks[0], blockDelta, startAmount, startAmount.sub(curve.relativeAmounts[0].toString()));
+        }
+        // the current pos is within or after the curve
+        const [prev, next] = locateArrayPosition(curve, blockDelta);
+        //relativeAmounts holds BigInts so we can't directly subtract without conversion
+        const lastAmount = startAmount.sub(curve.relativeAmounts[prev].toString());
+        const nextAmount = startAmount.sub(curve.relativeAmounts[next].toString());
+        return this.linearDecay(curve.relativeBlocks[prev], curve.relativeBlocks[next], blockDelta, lastAmount, nextAmount);
+    }
+    static linearDecay(startPoint, endPoint, currentPoint, startAmount, endAmount) {
+        if (currentPoint >= endPoint) {
+            return endAmount;
+        }
+        const elapsed = BigNumber.from(currentPoint - startPoint);
+        const duration = BigNumber.from(endPoint - startPoint);
+        let delta;
+        if (endAmount.lt(startAmount)) {
+            delta = BigNumber.from(0).sub((startAmount.sub(endAmount)).mul(elapsed).div(duration)); // mulDivDown in contract
+        }
+        else {
+            delta = (endAmount.sub(startAmount)).mul(elapsed).div(duration); // mulDivDown in contract
+        }
+        return startAmount.add(delta);
+    }
+}
+export { NonLinearDutchDecayLib };
+export function getBlockDecayedAmount(config, atBlock) {
+    const { decayStartBlock, startAmount, relativeBlocks, relativeAmounts } = config;
+    return NonLinearDutchDecayLib.decay({ relativeAmounts, relativeBlocks }, startAmount, decayStartBlock, atBlock);
+}
+export function getEndAmount(config) {
+    const { startAmount, relativeAmounts } = config;
+    if (!startAmount || !relativeAmounts) {
+        throw new Error("Invalid config for getting V3 decay end amount");
+    }
+    return startAmount.sub(relativeAmounts[relativeAmounts.length - 1].toString());
+}
+//# sourceMappingURL=dutchBlockDecay.js.map

package/dist/esm/src/utils/dutchBlockDecay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dutchBlockDecay.js","sourceRoot":"","sources":["../../../../src/utils/dutchBlockDecay.ts"],"names":[],"mappings":"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"}

package/dist/esm/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/esm/src/utils/dutchDecay.js

@@ -0,0 +1,28 @@
+export function getDecayedAmount(config, atTime = Math.floor(Date.now() / 1000)) {
+    const { startAmount, endAmount, decayStartTime, decayEndTime } = config;
+    // decay is over, return the ending amount
+    if (decayEndTime <= atTime) {
+        return endAmount;
+    }
+    // decay hasnt started, return the starting amount
+    if (decayStartTime >= atTime) {
+        return startAmount;
+    }
+    // no decay, just return the static amount
+    if (startAmount.eq(endAmount)) {
+        return startAmount;
+    }
+    const duration = decayEndTime - decayStartTime;
+    const elapsed = atTime - decayStartTime;
+    if (startAmount.gt(endAmount)) {
+        // decaying downward
+        const decay = startAmount.sub(endAmount).mul(elapsed).div(duration);
+        return startAmount.sub(decay);
+    }
+    else {
+        // decaying upward
+        const decay = endAmount.sub(startAmount).mul(elapsed).div(duration);
+        return startAmount.add(decay);
+    }
+}
+//# sourceMappingURL=dutchDecay.js.map

package/dist/esm/src/utils/dutchDecay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dutchDecay.js","sourceRoot":"","sources":["../../../../src/utils/dutchDecay.ts"],"names":[],"mappings":"AASA,MAAM,UAAU,gBAAgB,CAC9B,MAAwB,EACxB,SAAiB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;IAE9C,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC;IAExE,0CAA0C;IAC1C,IAAI,YAAY,IAAI,MAAM,EAAE;QAC1B,OAAO,SAAS,CAAC;KAClB;IAED,kDAAkD;IAClD,IAAI,cAAc,IAAI,MAAM,EAAE;QAC5B,OAAO,WAAW,CAAC;KACpB;IAED,0CAA0C;IAC1C,IAAI,WAAW,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE;QAC7B,OAAO,WAAW,CAAC;KACpB;IAED,MAAM,QAAQ,GAAG,YAAY,GAAG,cAAc,CAAC;IAC/C,MAAM,OAAO,GAAG,MAAM,GAAG,cAAc,CAAC;IACxC,IAAI,WAAW,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE;QAC7B,oBAAoB;QACpB,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACpE,OAAO,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;KAC/B;SAAM;QACL,kBAAkB;QAClB,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACpE,OAAO,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;KAC/B;AACH,CAAC"}

package/dist/esm/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/esm/src/utils/index.js

@@ -0,0 +1,44 @@
+import { PERMIT2_MAPPING, REACTOR_ADDRESS_MAPPING, } from "../constants";
+import { MissingConfiguration } from "../errors";
+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 function stripHexPrefix(a) {
+    if (a.startsWith("0x")) {
+        return a.slice(2);
+    }
+    else {
+        return a;
+    }
+}
+export function getPermit2(chainId, permit2Address) {
+    if (permit2Address) {
+        return permit2Address;
+    }
+    else if (PERMIT2_MAPPING[chainId]) {
+        return PERMIT2_MAPPING[chainId];
+    }
+    else {
+        throw new MissingConfiguration("permit2", chainId.toString());
+    }
+}
+export function getReactor(chainId, orderType, reactorAddress) {
+    const mappedReactorAddress = REACTOR_ADDRESS_MAPPING[chainId]
+        ? REACTOR_ADDRESS_MAPPING[chainId][orderType]
+        : undefined;
+    if (reactorAddress) {
+        return reactorAddress;
+    }
+    else if (mappedReactorAddress) {
+        return mappedReactorAddress;
+    }
+    else {
+        throw new MissingConfiguration("reactor", chainId.toString());
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/src/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EACf,uBAAuB,GACxB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEjD,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,8BAA8B,CAAC;AAE7C,MAAM,UAAU,cAAc,CAAC,CAAS;IACtC,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;QACtB,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;KACnB;SAAM;QACL,OAAO,CAAC,CAAC;KACV;AACH,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,OAAe,EAAE,cAAuB;IACjE,IAAI,cAAc,EAAE;QAClB,OAAO,cAAc,CAAC;KACvB;SAAM,IAAI,eAAe,CAAC,OAAO,CAAC,EAAE;QACnC,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC;KACjC;SAAM;QACL,MAAM,IAAI,oBAAoB,CAAC,SAAS,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;KAC/D;AACH,CAAC;AAED,MAAM,UAAU,UAAU,CACxB,OAAe,EACf,SAAoB,EACpB,cAAuB;IAEvB,MAAM,oBAAoB,GAAG,uBAAuB,CAAC,OAAO,CAAC;QAC3D,CAAC,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC;QAC7C,CAAC,CAAC,SAAS,CAAC;IACd,IAAI,cAAc,EAAE;QAClB,OAAO,cAAc,CAAC;KACvB;SAAM,IAAI,oBAAoB,EAAE;QAC/B,OAAO,oBAAoB,CAAC;KAC7B;SAAM;QACL,MAAM,IAAI,oBAAoB,CAAC,SAAS,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;KAC/D;AACH,CAAC"}

package/dist/esm/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/esm/src/utils/multicall.js

@@ -0,0 +1,87 @@
+// Uses deployless multicall to fetch responses and errors for multiple calls at once
+// https://github.com/Destiner/deployless-multicall
+import { __awaiter } from "tslib";
+import { Interface } from "@ethersproject/abi";
+import { hexConcat } from "@ethersproject/bytes";
+import { ethers } from "ethers";
+import deploylessMulticall2Abi from "../../abis/deploylessMulticall2.json";
+import multicall2Abi from "../../abis/multicall2.json";
+import { multicallAddressOn } from "../constants";
+import { Multicall2__factory } from "../contracts";
+const DEPLOYLESS_MULTICALL_BYTECODE = "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";
+// Perform multiple on-chain calls in a single http request
+// return all results including errors
+// Uses deployless method to function properly even on chains with no multicall contract deployed
+export function multicallSameContractManyFunctions(provider, params, stateOverrrides, blockOverrides) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { address, contractInterface, functionName, functionParams } = params;
+        const fragment = contractInterface.getFunction(functionName);
+        const calls = functionParams.map((functionParam) => {
+            const callData = contractInterface.encodeFunctionData(fragment, functionParam);
+            return {
+                target: address,
+                callData,
+            };
+        });
+        return multicall(provider, calls, stateOverrrides, blockOverrides);
+    });
+}
+export function multicallSameFunctionManyContracts(provider, params, stateOverrrides, blockOverrides) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { addresses, contractInterface, functionName, functionParam } = params;
+        const fragment = contractInterface.getFunction(functionName);
+        const callData = contractInterface.encodeFunctionData(fragment, functionParam);
+        const calls = addresses.map((address) => {
+            return {
+                target: address,
+                callData,
+            };
+        });
+        return multicall(provider, calls, stateOverrrides, blockOverrides);
+    });
+}
+export function multicall(provider, calls, stateOverrides, blockOverrides) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const chainId = (yield provider.getNetwork()).chainId;
+        const code = yield provider.getCode(multicallAddressOn(chainId));
+        let response;
+        if (code.length > 2) {
+            const multicall = Multicall2__factory.connect(multicallAddressOn(chainId), provider);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const params = [
+                {
+                    from: ethers.constants.AddressZero,
+                    to: multicall.address,
+                    data: multicall.interface.encodeFunctionData("tryAggregate", [false, calls]),
+                },
+                'latest',
+                (stateOverrides ? stateOverrides : {}),
+            ];
+            if (blockOverrides)
+                params.push(blockOverrides);
+            response = yield provider.send("eth_call", params);
+        }
+        else {
+            const deploylessInterface = new Interface(deploylessMulticall2Abi);
+            const args = deploylessInterface.encodeDeploy([false, calls]);
+            const data = hexConcat([DEPLOYLESS_MULTICALL_BYTECODE, args]);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const params = [
+                {
+                    from: ethers.constants.AddressZero,
+                    to: ethers.constants.AddressZero,
+                    data,
+                },
+                'latest',
+                (stateOverrides ? stateOverrides : {}),
+            ];
+            if (blockOverrides)
+                params.push(blockOverrides);
+            response = yield provider.send("eth_call", params);
+        }
+        const multicallInterface = new Interface(multicall2Abi);
+        return multicallInterface.decodeFunctionResult("tryAggregate", response)
+            .returnData;
+    });
+}
+//# sourceMappingURL=multicall.js.map

package/dist/esm/src/utils/multicall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multicall.js","sourceRoot":"","sources":["../../../../src/utils/multicall.ts"],"names":[],"mappings":"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"}

package/dist/esm/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/dist/esm/src/utils/order.js

@@ -0,0 +1,176 @@
+import { ethers } from "ethers";
+import { OrderType, REVERSE_REACTOR_MAPPING, REVERSE_RESOLVER_MAPPING, } from "../constants";
+import { MissingConfiguration } from "../errors";
+import { CosignedHybridOrder, CosignedPriorityOrder, CosignedV2DutchOrder, DutchOrder, RelayOrder, UnsignedHybridOrder, UnsignedPriorityOrder, UnsignedV2DutchOrder, } from "../order";
+import { CosignedV3DutchOrder, UnsignedV3DutchOrder } from "../order/V3DutchOrder";
+import { stripHexPrefix } from ".";
+const UNISWAPX_ORDER_INFO_OFFSET = 64;
+const RELAY_ORDER_INFO_OFFSET = 64;
+const SLOT_LENGTH = 64;
+const ADDRESS_LENGTH = 40;
+class OrderParser {
+    /**
+     * Parses a serialized order based on the order shape
+     * @dev called by derived classes which set the offset
+     */
+    _parseOrder(order) {
+        const strippedOrder = stripHexPrefix(order);
+        // look up the tail offset of orderInfo
+        // orderInfo is always the first field in the order,
+        // but since it is dynamic size it is a pointer in the tail
+        const orderInfoOffsetBytes = parseInt(strippedOrder.slice(this.orderInfoOffset, this.orderInfoOffset + SLOT_LENGTH), 16);
+        // multiply tail offset by 2 to get in terms of hex characters instead of bytes
+        // and add one slot to skip the orderinfo size slot
+        const reactorAddressOffset = orderInfoOffsetBytes * 2 + SLOT_LENGTH;
+        const reactorAddressSlot = strippedOrder.slice(reactorAddressOffset, reactorAddressOffset + SLOT_LENGTH);
+        // slice off the 0 padding in front of the address
+        const reactorAddress = ethers.utils
+            .getAddress(reactorAddressSlot.slice(SLOT_LENGTH - ADDRESS_LENGTH))
+            .toLowerCase();
+        if (!REVERSE_REACTOR_MAPPING[reactorAddress]) {
+            throw new MissingConfiguration("reactor", reactorAddress);
+        }
+        return REVERSE_REACTOR_MAPPING[reactorAddress].orderType;
+    }
+    /**
+     * Determines the OrderType from an Order object
+     * @return OrderType
+     */
+    getOrderType(order) {
+        const { orderType } = REVERSE_REACTOR_MAPPING[order.info.reactor.toLowerCase()];
+        return orderType;
+    }
+    /**
+     * Helper function to determine the OrderType from a serialized order
+     */
+    getOrderTypeFromEncoded(order, chainId) {
+        const parsedOrder = this.parseOrder(order, chainId);
+        return this.getOrderType(parsedOrder);
+    }
+}
+export class UniswapXOrderParser extends OrderParser {
+    constructor() {
+        super(...arguments);
+        this.orderInfoOffset = UNISWAPX_ORDER_INFO_OFFSET;
+    }
+    /**
+     * Parses a serialized order
+     */
+    parseOrder(order, chainId) {
+        // First try resolver-based detection for V4 orders
+        const v4OrderType = this.detectV4OrderType(order);
+        if (v4OrderType) {
+            return this.parseV4Order(order, chainId, v4OrderType);
+        }
+        // Fall back to reactor-based detection for V1-V3
+        const orderType = this._parseOrder(order);
+        switch (orderType) {
+            case OrderType.Dutch:
+                return DutchOrder.parse(order, chainId);
+            case OrderType.Dutch_V2: {
+                // cosigned and unsigned serialized versions are the same format
+                const cosignedOrder = CosignedV2DutchOrder.parse(order, chainId);
+                // if no cosignature, returned unsigned variant
+                if (cosignedOrder.info.cosignature === "0x") {
+                    return UnsignedV2DutchOrder.parse(order, chainId);
+                }
+                // if cosignature exists then returned cosigned version
+                return cosignedOrder;
+            }
+            case OrderType.Dutch_V3: {
+                // cosigned and unsigned serialized versions are the same format
+                const cosignedOrder = CosignedV3DutchOrder.parse(order, chainId);
+                // if no cosignature, returned unsigned variant
+                if (cosignedOrder.info.cosignature === "0x") {
+                    return UnsignedV3DutchOrder.parse(order, chainId);
+                }
+                // if cosignature exists then returned cosigned version
+                return cosignedOrder;
+            }
+            case OrderType.Priority: {
+                // cosigned and unsigned serialized versions are the same format
+                const cosignedOrder = CosignedPriorityOrder.parse(order, chainId);
+                // if no cosignature, returned unsigned variant
+                if (cosignedOrder.info.cosignature === "0x") {
+                    return UnsignedPriorityOrder.parse(order, chainId);
+                }
+                // if cosignature exists then returned cosigned version
+                return cosignedOrder;
+            }
+            default:
+                throw new MissingConfiguration("orderType", orderType);
+        }
+    }
+    /**
+     * Detects V4 order type by checking if the first address is a known resolver
+     * V4 orders are serialized as: (resolver, orderData)
+     */
+    detectV4OrderType(order) {
+        try {
+            const abiCoder = new ethers.utils.AbiCoder();
+            const [resolver] = abiCoder.decode(["address", "bytes"], order);
+            const resolverLower = resolver.toLowerCase();
+            if (REVERSE_RESOLVER_MAPPING[resolverLower]) {
+                return REVERSE_RESOLVER_MAPPING[resolverLower].orderType;
+            }
+        }
+        catch (_a) {
+            // Not a V4 order format
+        }
+        return null;
+    }
+    /**
+     * Parses a V4 order based on its resolver
+     */
+    parseV4Order(order, chainId, orderType) {
+        switch (orderType) {
+            case OrderType.Hybrid: {
+                const cosignedOrder = CosignedHybridOrder.parse(order, chainId);
+                if (cosignedOrder.info.cosignature === "0x") {
+                    return UnsignedHybridOrder.parse(order, chainId);
+                }
+                return cosignedOrder;
+            }
+            default:
+                throw new MissingConfiguration("v4OrderType", orderType);
+        }
+    }
+    /**
+     * 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) {
+        // V4 orders: check by instance type
+        if (order instanceof UnsignedHybridOrder ||
+            order instanceof CosignedHybridOrder) {
+            return OrderType.Hybrid;
+        }
+        // V1-V3 orders: use reactor-based lookup
+        const { orderType } = REVERSE_REACTOR_MAPPING[order.info.reactor.toLowerCase()];
+        if (orderType == OrderType.Dutch) {
+            const input = order.info.input;
+            const outputs = order.info.outputs;
+            const isLimit = input.startAmount.eq(input.endAmount) &&
+                outputs.every((output) => output.startAmount.eq(output.endAmount));
+            return isLimit ? OrderType.Limit : OrderType.Dutch;
+        }
+        return orderType;
+    }
+}
+export class RelayOrderParser extends OrderParser {
+    constructor() {
+        super(...arguments);
+        this.orderInfoOffset = RELAY_ORDER_INFO_OFFSET;
+    }
+    /**
+     * Parses a serialized order
+     */
+    parseOrder(order, chainId) {
+        return RelayOrder.parse(order, chainId);
+    }
+}
+export function originalIfZero(value, original) {
+    return value.isZero() ? original : value;
+}
+//# sourceMappingURL=order.js.map