@openocean.finance/openocean-sdk 0.1.72 → 0.1.73

package/lib/utils/limit-order-sdk/limit-order-protocol.facade.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitOrderProtocolFacade = void 0;
+var limit_order_protocol_const_1 = require("./limit-order-protocol.const");
+var limit_order_protocol_model_1 = require("./model/limit-order-protocol.model");
+var bignumber_1 = require("@ethersproject/bignumber");
+var get_rpc_code_1 = require("./utils/get-rpc-code");
+var LimitOrderProtocolFacade = /** @class */ (function () {
+    function LimitOrderProtocolFacade(contractAddress, providerConnector) {
+        this.contractAddress = contractAddress;
+        this.providerConnector = providerConnector;
+    }
+    LimitOrderProtocolFacade.prototype.fillLimitOrder = function (order, signature, makerAmount, takerAmount, thresholdAmount) {
+        return this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.fillOrder, [
+            order,
+            signature,
+            makerAmount,
+            takerAmount,
+            thresholdAmount,
+        ]);
+    };
+    LimitOrderProtocolFacade.prototype.fillOrderToWithPermit = function (params) {
+        var order = params.order, signature = params.signature, makerAmount = params.makerAmount, takerAmount = params.takerAmount, thresholdAmount = params.thresholdAmount, targetAddress = params.targetAddress, permit = params.permit;
+        return this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.fillOrderToWithPermit, [
+            order,
+            signature,
+            makerAmount,
+            takerAmount,
+            thresholdAmount,
+            targetAddress,
+            permit,
+        ]);
+    };
+    LimitOrderProtocolFacade.prototype.fillRFQOrder = function (order, signature, makerAmount, takerAmount) {
+        return this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.fillOrderRFQ, [order, signature, makerAmount, takerAmount]);
+    };
+    LimitOrderProtocolFacade.prototype.cancelLimitOrder = function (order) {
+        return this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.cancelOrder, [
+            order,
+        ]);
+    };
+    LimitOrderProtocolFacade.prototype.cancelRFQOrder = function (orderInfo) {
+        return this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.cancelOrderRFQ, [orderInfo]);
+    };
+    LimitOrderProtocolFacade.prototype.nonce = function (makerAddress) {
+        var callData = this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.nonce, [makerAddress]);
+        return this.providerConnector
+            .ethCall(this.contractAddress, callData)
+            .then(function (nonce) { return bignumber_1.BigNumber.from(nonce).toNumber(); });
+    };
+    LimitOrderProtocolFacade.prototype.advanceNonce = function (count) {
+        return this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.advanceNonce, [count]);
+    };
+    LimitOrderProtocolFacade.prototype.increaseNonce = function () {
+        return this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.increaseNonce);
+    };
+    LimitOrderProtocolFacade.prototype.checkPredicate = function (order) {
+        var callData = this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.checkPredicate, [order]);
+        return this.providerConnector
+            .ethCall(this.contractAddress, callData)
+            .catch(function (error) {
+            console.error(error);
+            return false;
+        })
+            .then(function (result) {
+            try {
+                return bignumber_1.BigNumber.from(result).toNumber() === 1;
+            }
+            catch (e) {
+                console.error(e);
+                return false;
+            }
+        });
+    };
+    LimitOrderProtocolFacade.prototype.remaining = function (orderHash) {
+        var _this = this;
+        var callData = this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.remaining, [orderHash]);
+        return this.providerConnector
+            .ethCall(this.contractAddress, callData)
+            .then(function (result) {
+            var response = _this.parseRemainingResponse(result);
+            if (response !== null) {
+                return response;
+            }
+            // Parse error
+            var parsed = _this.parseContractResponse(result);
+            return Promise.reject(parsed);
+        });
+    };
+    LimitOrderProtocolFacade.prototype.simulateCalls = function (tokens, data) {
+        var _this = this;
+        var callData = this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.simulateCalls, [tokens, data]);
+        return this.providerConnector
+            .ethCall(this.contractAddress, callData)
+            .then(function (result) {
+            var parsed = _this.parseSimulateTransferResponse(result);
+            if (parsed !== null)
+                return parsed;
+            return Promise.reject(result);
+        })
+            .catch(function (error) {
+            var parsed = _this.parseSimulateTransferError(error);
+            if (parsed !== null)
+                return parsed;
+            return Promise.reject(error);
+        });
+    };
+    LimitOrderProtocolFacade.prototype.domainSeparator = function () {
+        var callData = this.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.DOMAIN_SEPARATOR);
+        return this.providerConnector.ethCall(this.contractAddress, callData);
+    };
+    LimitOrderProtocolFacade.prototype.getContractCallData = function (methodName, methodParams) {
+        if (methodParams === void 0) { methodParams = []; }
+        return this.providerConnector.contractEncodeABI(limit_order_protocol_const_1.LIMIT_ORDER_PROTOCOL_ABI, this.contractAddress, methodName, methodParams);
+    };
+    LimitOrderProtocolFacade.prototype.parseRemainingResponse = function (response) {
+        if (response.length === 66) {
+            return bignumber_1.BigNumber.from(response);
+        }
+        return null;
+    };
+    LimitOrderProtocolFacade.prototype.parseSimulateTransferResponse = function (response) {
+        var parsed = this.parseContractResponse(response);
+        if (parsed.startsWith(limit_order_protocol_const_1.CALL_RESULTS_PREFIX)) {
+            var data = parsed.replace(limit_order_protocol_const_1.CALL_RESULTS_PREFIX, '');
+            return !data.includes('0');
+        }
+        return null;
+    };
+    LimitOrderProtocolFacade.prototype.parseSimulateTransferError = function (error) {
+        var message = this.stringifyError(error);
+        var isCorrectCode = this.isMsgContainsCorrectCode(message);
+        if (isCorrectCode !== null) {
+            return isCorrectCode;
+        }
+        try {
+            var code = get_rpc_code_1.getRPCCode(message);
+            return code ? this.isMsgContainsCorrectCode(code) : null;
+        }
+        catch (e) {
+            return null;
+        }
+    };
+    LimitOrderProtocolFacade.prototype.parseContractResponse = function (response) {
+        // Aurora network wraps revert message into Revert()
+        var matched = response.match(/Revert\(([^)]+)\)/);
+        var message = matched && matched[1] ? matched[1] : response;
+        return this.providerConnector.decodeABIParameter('string', limit_order_protocol_const_1.ZX + message.slice(10));
+    };
+    LimitOrderProtocolFacade.prototype.isMsgContainsCorrectCode = function (message) {
+        var regex = new RegExp('(' + limit_order_protocol_const_1.CALL_RESULTS_PREFIX + '\\d+)');
+        var matched = message.match(regex);
+        if (matched) {
+            return !matched[0].includes('0');
+        }
+        else {
+            try {
+                var matchParsed = this.parseContractResponse(message).match(regex);
+                if (matchParsed) {
+                    return !matchParsed[0].includes('0');
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        return null;
+    };
+    LimitOrderProtocolFacade.prototype.stringifyError = function (error) {
+        if (typeof error === 'string') {
+            return error;
+        }
+        if (error instanceof Error) {
+            return error.toString();
+        }
+        return JSON.stringify(error);
+    };
+    return LimitOrderProtocolFacade;
+}());
+exports.LimitOrderProtocolFacade = LimitOrderProtocolFacade;

package/lib/utils/limit-order-sdk/limit-order.builder.d.ts

@@ -0,0 +1,101 @@
+export var __esModule: boolean;
+export function generateOrderSalt(): string;
+export function generateRFQOrderInfo(id: any, expiresInTimestamp: any, wrapEth: any): string;
+export class LimitOrderBuilder {
+    constructor(contractAddress: any, chainId: any, providerConnector: any, generateSalt?: typeof generateOrderSalt);
+    contractAddress: any;
+    chainId: any;
+    providerConnector: any;
+    generateSalt: typeof generateOrderSalt;
+    buildOrderSignature(walletAddress: any, typedData: any): any;
+    buildLimitOrderHash(orderTypedData: any): string;
+    buildLimitOrderTypedData(order: any, domainName?: string): {
+        primaryType: string;
+        types: {
+            EIP712Domain: {
+                name: string;
+                type: string;
+            }[];
+            Order: {
+                name: string;
+                type: string;
+            }[];
+        };
+        domain: {
+            name: string;
+            version: string;
+            chainId: any;
+            verifyingContract: any;
+        };
+        message: any;
+    };
+    buildRFQOrderTypedData(order: any, domainName?: string): {
+        primaryType: string;
+        types: {
+            EIP712Domain: {
+                name: string;
+                type: string;
+            }[];
+            OrderRFQ: {
+                name: string;
+                type: string;
+            }[];
+        };
+        domain: {
+            name: string;
+            version: string;
+            chainId: any;
+            verifyingContract: any;
+        };
+        message: any;
+    };
+    buildRFQOrder({ id, wrapEth, expiresInTimestamp, makerAssetAddress, takerAssetAddress, makerAddress, takerAddress, makerAmount, takerAmount, }: {
+        id: any;
+        wrapEth?: boolean | undefined;
+        expiresInTimestamp: any;
+        makerAssetAddress: any;
+        takerAssetAddress: any;
+        makerAddress: any;
+        takerAddress?: string | undefined;
+        makerAmount: any;
+        takerAmount: any;
+    }): {
+        info: string;
+        makerAsset: any;
+        takerAsset: any;
+        maker: any;
+        allowedSender: string;
+        makingAmount: any;
+        takingAmount: any;
+    };
+    buildLimitOrder({ makerAssetAddress, takerAssetAddress, makerAddress, receiver, takerAddress, makerAmount, takerAmount, predicate, permit, interaction, }: {
+        makerAssetAddress: any;
+        takerAssetAddress: any;
+        makerAddress: any;
+        receiver?: string | undefined;
+        takerAddress?: string | undefined;
+        makerAmount: any;
+        takerAmount: any;
+        predicate?: string | undefined;
+        permit?: string | undefined;
+        interaction?: string | undefined;
+    }): {
+        salt: string;
+        makerAsset: any;
+        takerAsset: any;
+        maker: any;
+        receiver: string;
+        allowedSender: string;
+        makingAmount: any;
+        takingAmount: any;
+        makerAssetData: string;
+        takerAssetData: string;
+        getMakerAmount: any;
+        getTakerAmount: any;
+        predicate: string;
+        permit: string;
+        interaction: string;
+    };
+    getContractCallData(methodName: any, methodParams?: any[]): any;
+    getAmountData(methodName: any, makerAmount: any, takerAmount: any, swapTakerAmount?: string): any;
+}

package/lib/utils/limit-order-sdk/limit-order.builder.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitOrderBuilder = exports.generateRFQOrderInfo = exports.generateOrderSalt = void 0;
+var limit_order_protocol_const_1 = require("./limit-order-protocol.const");
+var limit_order_protocol_model_1 = require("./model/limit-order-protocol.model");
+var eth_sig_util_1 = require("eth-sig-util");
+function generateOrderSalt() {
+    return Math.round(Math.random() * Date.now()) + '';
+}
+exports.generateOrderSalt = generateOrderSalt;
+function generateRFQOrderInfo(id, expiresInTimestamp, wrapEth) {
+    var info = (BigInt(expiresInTimestamp) << BigInt(64)) | BigInt(id);
+    if (wrapEth) {
+        return (info | (BigInt(1) << BigInt(255))).toString(10);
+    }
+    return info.toString(10);
+}
+exports.generateRFQOrderInfo = generateRFQOrderInfo;
+var LimitOrderBuilder = /** @class */ (function () {
+    function LimitOrderBuilder(contractAddress, chainId, providerConnector, generateSalt) {
+        if (generateSalt === void 0) { generateSalt = generateOrderSalt; }
+        this.contractAddress = contractAddress;
+        this.chainId = chainId;
+        this.providerConnector = providerConnector;
+        this.generateSalt = generateSalt;
+    }
+    LimitOrderBuilder.prototype.buildOrderSignature = function (walletAddress, typedData) {
+        var dataHash = eth_sig_util_1.TypedDataUtils.hashStruct(typedData.primaryType, typedData.message, typedData.types, true).toString('hex');
+        return this.providerConnector.signTypedData(walletAddress, typedData, dataHash);
+    };
+    LimitOrderBuilder.prototype.buildLimitOrderHash = function (orderTypedData) {
+        var message = orderTypedData;
+        return limit_order_protocol_const_1.ZX + eth_sig_util_1.TypedDataUtils.sign(message).toString('hex');
+    };
+    LimitOrderBuilder.prototype.buildLimitOrderTypedData = function (order, domainName) {
+        if (domainName === void 0) { domainName = limit_order_protocol_const_1.PROTOCOL_NAME; }
+        return {
+            primaryType: 'Order',
+            types: {
+                EIP712Domain: limit_order_protocol_const_1.EIP712_DOMAIN,
+                Order: limit_order_protocol_const_1.ORDER_STRUCTURE,
+            },
+            domain: {
+                name: domainName,
+                version: limit_order_protocol_const_1.PROTOCOL_VERSION,
+                chainId: this.chainId,
+                verifyingContract: this.contractAddress,
+            },
+            message: order,
+        };
+    };
+    LimitOrderBuilder.prototype.buildRFQOrderTypedData = function (order, domainName) {
+        if (domainName === void 0) { domainName = limit_order_protocol_const_1.PROTOCOL_NAME; }
+        return {
+            primaryType: 'OrderRFQ',
+            types: {
+                EIP712Domain: limit_order_protocol_const_1.EIP712_DOMAIN,
+                OrderRFQ: limit_order_protocol_const_1.RFQ_ORDER_STRUCTURE,
+            },
+            domain: {
+                name: domainName,
+                version: limit_order_protocol_const_1.PROTOCOL_VERSION,
+                chainId: this.chainId,
+                verifyingContract: this.contractAddress,
+            },
+            message: order,
+        };
+    };
+    /* eslint-disable max-lines-per-function */
+    LimitOrderBuilder.prototype.buildRFQOrder = function (_a) {
+        var id = _a.id, _b = _a.wrapEth, wrapEth = _b === void 0 ? false : _b, expiresInTimestamp = _a.expiresInTimestamp, makerAssetAddress = _a.makerAssetAddress, takerAssetAddress = _a.takerAssetAddress, makerAddress = _a.makerAddress, _c = _a.takerAddress, takerAddress = _c === void 0 ? limit_order_protocol_const_1.ZERO_ADDRESS : _c, makerAmount = _a.makerAmount, takerAmount = _a.takerAmount;
+        return {
+            info: generateRFQOrderInfo(id, expiresInTimestamp, wrapEth),
+            makerAsset: makerAssetAddress,
+            takerAsset: takerAssetAddress,
+            maker: makerAddress,
+            allowedSender: takerAddress,
+            makingAmount: makerAmount,
+            takingAmount: takerAmount,
+        };
+    };
+    /* eslint-enable max-lines-per-function */
+    /* eslint-disable max-lines-per-function */
+    LimitOrderBuilder.prototype.buildLimitOrder = function (_a) {
+        var makerAssetAddress = _a.makerAssetAddress, takerAssetAddress = _a.takerAssetAddress, makerAddress = _a.makerAddress, _b = _a.receiver, receiver = _b === void 0 ? limit_order_protocol_const_1.ZERO_ADDRESS : _b, _c = _a.takerAddress, takerAddress = _c === void 0 ? limit_order_protocol_const_1.ZERO_ADDRESS : _c, makerAmount = _a.makerAmount, takerAmount = _a.takerAmount, _d = _a.predicate, predicate = _d === void 0 ? limit_order_protocol_const_1.ZX : _d, _e = _a.permit, permit = _e === void 0 ? limit_order_protocol_const_1.ZX : _e, _f = _a.interaction, interaction = _f === void 0 ? limit_order_protocol_const_1.ZX : _f;
+        return {
+            salt: this.generateSalt(),
+            makerAsset: makerAssetAddress,
+            takerAsset: takerAssetAddress,
+            maker: makerAddress,
+            receiver: receiver,
+            allowedSender: takerAddress,
+            makingAmount: makerAmount,
+            takingAmount: takerAmount,
+            makerAssetData: limit_order_protocol_const_1.ZX,
+            takerAssetData: limit_order_protocol_const_1.ZX,
+            getMakerAmount: this.getAmountData(limit_order_protocol_model_1.LimitOrderProtocolMethods.getMakerAmount, makerAmount, takerAmount),
+            getTakerAmount: this.getAmountData(limit_order_protocol_model_1.LimitOrderProtocolMethods.getTakerAmount, makerAmount, takerAmount),
+            predicate: predicate,
+            permit: permit,
+            interaction: interaction,
+        };
+    };
+    /* eslint-enable max-lines-per-function */
+    LimitOrderBuilder.prototype.getContractCallData = function (methodName, methodParams) {
+        if (methodParams === void 0) { methodParams = []; }
+        return this.providerConnector.contractEncodeABI(limit_order_protocol_const_1.LIMIT_ORDER_PROTOCOL_ABI, this.contractAddress, methodName, methodParams);
+    };
+    // Get nonce from contract (nonce method) and put it to predicate on order creating
+    LimitOrderBuilder.prototype.getAmountData = function (methodName, makerAmount, takerAmount, swapTakerAmount) {
+        if (swapTakerAmount === void 0) { swapTakerAmount = '0'; }
+        return this.getContractCallData(methodName, [
+            makerAmount,
+            takerAmount,
+            swapTakerAmount,
+        ]).substr(0, 2 + 68 * 2);
+    };
+    return LimitOrderBuilder;
+}());
+exports.LimitOrderBuilder = LimitOrderBuilder;

package/lib/utils/limit-order-sdk/model/abi.model.d.ts

@@ -0,0 +1 @@
+export var __esModule: boolean;

package/lib/utils/limit-order-sdk/model/abi.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/limit-order-sdk/model/eip712.model.d.ts

@@ -0,0 +1 @@
+export var __esModule: boolean;

package/lib/utils/limit-order-sdk/model/eip712.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/limit-order-sdk/model/limit-order-protocol.model.d.ts

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var ChainId: {};
+export var LimitOrderProtocolMethods: {};

package/lib/utils/limit-order-sdk/model/limit-order-protocol.model.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitOrderProtocolMethods = exports.ChainId = void 0;
+var ChainId;
+(function (ChainId) {
+    ChainId[ChainId["etherumMainnet"] = 1] = "etherumMainnet";
+    ChainId[ChainId["binanceMainnet"] = 56] = "binanceMainnet";
+    ChainId[ChainId["polygonMainnet"] = 137] = "polygonMainnet";
+    ChainId[ChainId["optimismMainnet"] = 10] = "optimismMainnet";
+    ChainId[ChainId["arbitrumMainnet"] = 42161] = "arbitrumMainnet";
+})(ChainId = exports.ChainId || (exports.ChainId = {}));
+var LimitOrderProtocolMethods;
+(function (LimitOrderProtocolMethods) {
+    LimitOrderProtocolMethods["getMakerAmount"] = "getMakerAmount";
+    LimitOrderProtocolMethods["getTakerAmount"] = "getTakerAmount";
+    LimitOrderProtocolMethods["arbitraryStaticCall"] = "arbitraryStaticCall";
+    LimitOrderProtocolMethods["fillOrder"] = "fillOrder";
+    LimitOrderProtocolMethods["fillOrderToWithPermit"] = "fillOrderToWithPermit";
+    LimitOrderProtocolMethods["fillOrderRFQ"] = "fillOrderRFQ";
+    LimitOrderProtocolMethods["cancelOrder"] = "cancelOrder";
+    LimitOrderProtocolMethods["cancelOrderRFQ"] = "cancelOrderRFQ";
+    LimitOrderProtocolMethods["nonce"] = "nonce";
+    LimitOrderProtocolMethods["advanceNonce"] = "advanceNonce";
+    LimitOrderProtocolMethods["increaseNonce"] = "increaseNonce";
+    LimitOrderProtocolMethods["and"] = "and";
+    LimitOrderProtocolMethods["or"] = "or";
+    LimitOrderProtocolMethods["eq"] = "eq";
+    LimitOrderProtocolMethods["lt"] = "lt";
+    LimitOrderProtocolMethods["gt"] = "gt";
+    LimitOrderProtocolMethods["timestampBelow"] = "timestampBelow";
+    LimitOrderProtocolMethods["nonceEquals"] = "nonceEquals";
+    LimitOrderProtocolMethods["remaining"] = "remaining";
+    LimitOrderProtocolMethods["transferFrom"] = "transferFrom";
+    LimitOrderProtocolMethods["checkPredicate"] = "checkPredicate";
+    LimitOrderProtocolMethods["remainingsRaw"] = "remainingsRaw";
+    LimitOrderProtocolMethods["simulateCalls"] = "simulateCalls";
+    LimitOrderProtocolMethods["DOMAIN_SEPARATOR"] = "DOMAIN_SEPARATOR";
+})(LimitOrderProtocolMethods = exports.LimitOrderProtocolMethods || (exports.LimitOrderProtocolMethods = {}));

package/lib/utils/limit-order-sdk/utils/get-rpc-code.d.ts

@@ -0,0 +1,2 @@
+export var __esModule: boolean;
+export function getRPCCode(response: any): any;

package/lib/utils/limit-order-sdk/utils/get-rpc-code.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRPCCode = void 0;
+var tslib_1 = require("tslib");
+var web3_1 = tslib_1.__importDefault(require("web3"));
+function getRPCCode(response) {
+    var objectRegexp = /{(\n*|.*)*}/gi; // take all between { }
+    var match = response.match(objectRegexp);
+    var matched = match ? match[0] : null;
+    var rpcError = matched ? parseErrorObject(matched) : null;
+    var data = rpcError ? rpcError.data : null;
+    return data ? extractCodeFromData(data) : null;
+}
+exports.getRPCCode = getRPCCode;
+function extractCodeFromData(data) {
+    var hexRegexp = /0[xX][0-9a-fA-F]+/;
+    var matched = data.match(hexRegexp);
+    var hex = matched === null || matched === void 0 ? void 0 : matched[0];
+    return hex ? web3_1.default.utils.hexToAscii(hex) : null;
+}
+function parseErrorObject(errorObjectString) {
+    try {
+        return JSON.parse(errorObjectString);
+    }
+    catch (e) {
+        return null;
+    }
+}

package/lib/utils/limit-order-sdk/utils/limit-order-rfq.const.d.ts

@@ -0,0 +1,89 @@
+export var __esModule: boolean;
+export var operationSchema: {
+    type: string;
+    name: string;
+    choices: {
+        title: string;
+        value: string;
+    }[];
+    message: string;
+}[];
+export var createOrderSchema: ({
+    type: string;
+    name: string;
+    message: string;
+    choices: {
+        title: string;
+        value: limit_order_protocol_model_1.ChainId;
+    }[];
+} | {
+    type: string;
+    name: string;
+    message: string;
+    choices?: undefined;
+} | {
+    type: string;
+    name: string;
+    message: string;
+    initial: number;
+})[];
+export var fillOrderSchema: ({
+    type: string;
+    name: string;
+    message: string;
+    choices: {
+        title: string;
+        value: limit_order_protocol_model_1.ChainId;
+    }[];
+} | {
+    type: string;
+    name: string;
+    message: string;
+    choices?: undefined;
+} | {
+    type: string;
+    name: string;
+    message: string;
+    initial: number;
+})[];
+export var cancelOrderSchema: ({
+    type: string;
+    name: string;
+    message: string;
+    choices: {
+        title: string;
+        value: limit_order_protocol_model_1.ChainId;
+    }[];
+} | {
+    type: string;
+    name: string;
+    message: string;
+    choices?: undefined;
+} | {
+    type: string;
+    name: string;
+    message: string;
+    initial: number;
+})[];
+export var rpcUrls: {
+    1: string;
+    56: string;
+    137: string;
+    10: string;
+    42161: string;
+};
+export var contractAddresses: {
+    1: string;
+    56: string;
+    137: string;
+    10: string;
+    42161: string;
+};
+export var explorersUrls: {
+    1: string;
+    56: string;
+    137: string;
+    10: string;
+    42161: string;
+};
+import limit_order_protocol_model_1 = require("../model/limit-order-protocol.model");