@openocean.finance/openocean-sdk 0.1.71 → 0.1.73

package/lib/utils/ajx.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.post = exports.get = exports.validateReq = void 0;
+var class_validator_1 = require("class-validator");
+var class_transformer_1 = require("class-transformer");
+var axios = require('axios');
+function validateReq(option, vo) {
+    return __awaiter(this, void 0, void 0, function () {
+        var reqAllowanceVo, errors;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    reqAllowanceVo = (0, class_transformer_1.plainToClass)(vo, option);
+                    return [4 /*yield*/, (0, class_validator_1.validate)(reqAllowanceVo)];
+                case 1:
+                    errors = _a.sent();
+                    if (errors.length) {
+                        return [2 /*return*/, errors.reduce(function (o, n) {
+                                Object.keys(n.constraints).forEach(function (key) {
+                                    o.push(n.constraints[key]);
+                                });
+                                return o;
+                            }, []).join(', ')];
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.validateReq = validateReq;
+function get(url, option, vo) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                    var errors, error_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, validateReq(option, vo)];
+                            case 1:
+                                errors = _a.sent();
+                                if (errors) {
+                                    reject(errors);
+                                }
+                                else {
+                                    axios({
+                                        method: 'get',
+                                        url: "".concat(url),
+                                        params: option
+                                    })
+                                        .then(function (response) {
+                                        resolve(response.data);
+                                    })
+                                        .catch(function (error) {
+                                        reject(error ? error.message : 'An unknown error');
+                                    });
+                                }
+                                return [3 /*break*/, 3];
+                            case 2:
+                                error_1 = _a.sent();
+                                reject(error_1 || 'An unknown error');
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); })];
+        });
+    });
+}
+exports.get = get;
+function post(url, option, vo) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                    var errors, error_2;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, validateReq(option, vo)];
+                            case 1:
+                                errors = _a.sent();
+                                if (errors) {
+                                    reject(errors);
+                                }
+                                else {
+                                    axios({
+                                        method: 'post',
+                                        url: "".concat(url),
+                                        data: option
+                                    })
+                                        .then(function (response) {
+                                        resolve(response.data);
+                                    })
+                                        .catch(function (error) {
+                                        reject(error ? error.message : 'An unknown error');
+                                    });
+                                }
+                                return [3 /*break*/, 3];
+                            case 2:
+                                error_2 = _a.sent();
+                                reject(error_2 || 'An unknown error');
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); })];
+        });
+    });
+}
+exports.post = post;

package/lib/utils/index.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPc = exports.utils = exports.Utils = exports.ChainNames = void 0;
+var axios = require('axios');
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+var ChainNames;
+(function (ChainNames) {
+    ChainNames[ChainNames["eth"] = 0] = "eth";
+    ChainNames[ChainNames["solana"] = 1] = "solana";
+    ChainNames[ChainNames["ont"] = 2] = "ont";
+    ChainNames[ChainNames["terra"] = 3] = "terra";
+    ChainNames[ChainNames["tron"] = 4] = "tron";
+    ChainNames[ChainNames["osmosis"] = 5] = "osmosis";
+    ChainNames[ChainNames["sifchain"] = 6] = "sifchain";
+    ChainNames[ChainNames["ropsten"] = 7] = "ropsten";
+    ChainNames[ChainNames["bsc"] = 8] = "bsc";
+    ChainNames[ChainNames["okex"] = 9] = "okex";
+    ChainNames[ChainNames["polygon"] = 10] = "polygon";
+    ChainNames[ChainNames["fantom"] = 11] = "fantom";
+    ChainNames[ChainNames["heco"] = 12] = "heco";
+    ChainNames[ChainNames["avax"] = 13] = "avax";
+    ChainNames[ChainNames["arbitrum"] = 14] = "arbitrum";
+    ChainNames[ChainNames["xdai"] = 15] = "xdai";
+    ChainNames[ChainNames["optimism"] = 16] = "optimism";
+    ChainNames[ChainNames["boba"] = 17] = "boba";
+    ChainNames[ChainNames["moonriver"] = 18] = "moonriver";
+    ChainNames[ChainNames["aurora"] = 19] = "aurora";
+    ChainNames[ChainNames["cronos"] = 20] = "cronos";
+    ChainNames[ChainNames["cosmos"] = 21] = "cosmos";
+    ChainNames[ChainNames["harmony"] = 22] = "harmony";
+    ChainNames[ChainNames["bsctest"] = 23] = "bsctest";
+})(ChainNames = exports.ChainNames || (exports.ChainNames = {}));
+var Utils = /** @class */ (function () {
+    function Utils() {
+    }
+    Utils.prototype.sleep = function (interval) {
+        return new Promise(function (resolve) {
+            setTimeout(resolve, interval);
+        });
+    };
+    Utils.prototype.getShift = function (a, b) {
+        return new bignumber_js_1.default(a).shiftedBy(Number(b)).toFixed();
+    };
+    Utils.prototype.decimals2Amount = function (amount, decimals) {
+        return this.getShift(amount, -decimals);
+    };
+    Utils.prototype.amount2Decimals = function (amount, decimals) {
+        return this.getFixed(this.getShift(amount, decimals), 0);
+    };
+    Utils.prototype.getFixed = function (val, fixed, trailingZeros) {
+        var numStr = val || '0';
+        if (trailingZeros) {
+            return new bignumber_js_1.default(numStr).toFixed(fixed);
+        }
+        return new bignumber_js_1.default(numStr).decimalPlaces(fixed).toString();
+    };
+    Utils.prototype.toFixed = function (n, k, z) {
+        if (isNaN(n)) {
+            return 0;
+        }
+        if (!k)
+            k = 4;
+        var a = Math.pow(10, k);
+        if (Number(n) < 0) {
+            a = Math.ceil(Number(n) * a) / a;
+        }
+        else {
+            a = Math.floor(Number(n) * a) / a;
+        }
+        if (!z) {
+            return a;
+        }
+        else {
+            return a.toFixed(k);
+        }
+    };
+    return Utils;
+}());
+exports.Utils = Utils;
+exports.utils = new Utils();
+function isPc() {
+    var userAgent = navigator.userAgent, Agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
+    console.log('userAgent:', userAgent);
+    return Agents.some(function (i) {
+        return userAgent.includes(i);
+    });
+}
+exports.isPc = isPc;

package/lib/utils/limit-order-sdk/connector/private-key-provider.connector.d.ts

@@ -0,0 +1,10 @@
+export var __esModule: boolean;
+export class PrivateKeyProviderConnector {
+    constructor(privateKey: any, web3Provider: any);
+    privateKey: any;
+    web3Provider: any;
+    contractEncodeABI(abi: any, address: any, methodName: any, methodParams: any): any;
+    signTypedData(_walletAddress: any, typedData: any, _typedDataHash?: string): Promise<any>;
+    ethCall(contractAddress: any, callData: any): any;
+    decodeABIParameter(type: any, hex: any): any;
+}

package/lib/utils/limit-order-sdk/connector/private-key-provider.connector.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateKeyProviderConnector = void 0;
+var eth_sig_util_1 = require("eth-sig-util");
+var PrivateKeyProviderConnector = /** @class */ (function () {
+    function PrivateKeyProviderConnector(privateKey, web3Provider) {
+        this.privateKey = privateKey;
+        this.web3Provider = web3Provider;
+    }
+    PrivateKeyProviderConnector.prototype.contractEncodeABI = function (abi, address, methodName, methodParams) {
+        var _a;
+        var contract = new this.web3Provider.eth.Contract(abi, address === null ? undefined : address);
+        return (_a = contract.methods)[methodName].apply(_a, methodParams).encodeABI();
+    };
+    PrivateKeyProviderConnector.prototype.signTypedData = function (_walletAddress, typedData, 
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    _typedDataHash) {
+        if (_typedDataHash === void 0) { _typedDataHash = ''; }
+        var result = eth_sig_util_1.signTypedData_v4(Buffer.from(this.privateKey, 'hex'), {
+            data: typedData,
+            /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+        });
+        return Promise.resolve(result);
+    };
+    PrivateKeyProviderConnector.prototype.ethCall = function (contractAddress, callData) {
+        return this.web3Provider.eth.call({
+            to: contractAddress,
+            data: callData,
+        });
+    };
+    PrivateKeyProviderConnector.prototype.decodeABIParameter = function (type, hex) {
+        return this.web3Provider.eth.abi.decodeParameter(type, hex);
+    };
+    return PrivateKeyProviderConnector;
+}());
+exports.PrivateKeyProviderConnector = PrivateKeyProviderConnector;

package/lib/utils/limit-order-sdk/connector/provider.connector.d.ts

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

package/lib/utils/limit-order-sdk/connector/provider.connector.js

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

package/lib/utils/limit-order-sdk/connector/web3-provider.connector.d.ts

@@ -0,0 +1,9 @@
+export var __esModule: boolean;
+export class Web3ProviderConnector {
+    constructor(web3Provider: any);
+    web3Provider: any;
+    contractEncodeABI(abi: any, address: any, methodName: any, methodParams: any): any;
+    signTypedData(walletAddress: any, typedData: any, _typedDataHash: any): any;
+    ethCall(contractAddress: any, callData: any): any;
+    decodeABIParameter(type: any, hex: any): any;
+}

package/lib/utils/limit-order-sdk/connector/web3-provider.connector.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Web3ProviderConnector = void 0;
+var Web3ProviderConnector = /** @class */ (function () {
+    function Web3ProviderConnector(web3Provider) {
+        this.web3Provider = web3Provider;
+    }
+    Web3ProviderConnector.prototype.contractEncodeABI = function (abi, address, methodName, methodParams) {
+        var _a;
+        var contract = new this.web3Provider.eth.Contract(abi, address === null ? undefined : address);
+        return (_a = contract.methods)[methodName].apply(_a, methodParams).encodeABI();
+    };
+    Web3ProviderConnector.prototype.signTypedData = function (walletAddress, typedData, 
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    _typedDataHash) {
+        var extendedWeb3 = this.web3Provider.extend({
+            methods: [
+                {
+                    name: 'signTypedDataV4',
+                    call: 'eth_signTypedData_v4',
+                    params: 2,
+                },
+            ],
+        });
+        return extendedWeb3.signTypedDataV4(walletAddress, JSON.stringify(typedData));
+    };
+    Web3ProviderConnector.prototype.ethCall = function (contractAddress, callData) {
+        return this.web3Provider.eth.call({
+            to: contractAddress,
+            data: callData,
+        });
+    };
+    Web3ProviderConnector.prototype.decodeABIParameter = function (type, hex) {
+        return this.web3Provider.eth.abi.decodeParameter(type, hex);
+    };
+    return Web3ProviderConnector;
+}());
+exports.Web3ProviderConnector = Web3ProviderConnector;

package/lib/utils/limit-order-sdk/erc20.facade.d.ts

@@ -0,0 +1,7 @@
+export var __esModule: boolean;
+export var Erc20Methods: {};
+export class Erc20Facade {
+    constructor(providerConnector: any);
+    providerConnector: any;
+    balanceOf(tokenAddress: any, walletAddress: any): any;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Erc20Facade = exports.Erc20Methods = void 0;
+var limit_order_protocol_const_1 = require("./limit-order-protocol.const");
+var Erc20Methods;
+(function (Erc20Methods) {
+    Erc20Methods["transferFrom"] = "transferFrom";
+    Erc20Methods["balanceOf"] = "balanceOf";
+})(Erc20Methods = exports.Erc20Methods || (exports.Erc20Methods = {}));
+var Erc20Facade = /** @class */ (function () {
+    function Erc20Facade(providerConnector) {
+        this.providerConnector = providerConnector;
+    }
+    Erc20Facade.prototype.balanceOf = function (tokenAddress, walletAddress) {
+        return this.providerConnector.contractEncodeABI(limit_order_protocol_const_1.ERC20_ABI, tokenAddress, Erc20Methods.balanceOf, [walletAddress]);
+    };
+    return Erc20Facade;
+}());
+exports.Erc20Facade = Erc20Facade;

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./erc20.facade"), exports);
+tslib_1.__exportStar(require("./limit-order.builder"), exports);
+tslib_1.__exportStar(require("./limit-order-predicate.builder"), exports);
+tslib_1.__exportStar(require("./limit-order-protocol.const"), exports);
+tslib_1.__exportStar(require("./limit-order-protocol.facade"), exports);
+tslib_1.__exportStar(require("./connector/provider.connector"), exports);
+tslib_1.__exportStar(require("./connector/web3-provider.connector"), exports);
+tslib_1.__exportStar(require("./connector/private-key-provider.connector"), exports);
+tslib_1.__exportStar(require("./model/abi.model"), exports);
+tslib_1.__exportStar(require("./model/eip712.model"), exports);
+tslib_1.__exportStar(require("./model/limit-order-protocol.model"), exports);

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

@@ -0,0 +1,12 @@
+export var __esModule: boolean;
+export class LimitOrderPredicateBuilder {
+    constructor(facade: any);
+    facade: any;
+    and: (...predicates: any[]) => any;
+    or: (...predicates: any[]) => any;
+    eq: (value: any, address: any, callData: any) => any;
+    lt: (value: any, address: any, callData: any) => any;
+    gt: (value: any, address: any, callData: any) => any;
+    nonceEquals: (makerAddress: any, makerNonce: any) => any;
+    timestampBelow: (timestamp: any) => any;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitOrderPredicateBuilder = void 0;
+var limit_order_protocol_model_1 = require("./model/limit-order-protocol.model");
+var limit_order_protocol_const_1 = require("./limit-order-protocol.const");
+var LimitOrderPredicateBuilder = /** @class */ (function () {
+    function LimitOrderPredicateBuilder(facade) {
+        var _this = this;
+        this.facade = facade;
+        this.and = function () {
+            var predicates = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                predicates[_i] = arguments[_i];
+            }
+            return _this.facade.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.and, [
+                predicates.map(function () { return _this.facade.contractAddress; }),
+                predicates,
+            ]);
+        };
+        this.or = function () {
+            var predicates = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                predicates[_i] = arguments[_i];
+            }
+            return _this.facade.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.or, [
+                predicates.map(function () { return _this.facade.contractAddress; }),
+                predicates,
+            ]);
+        };
+        this.eq = function (value, address, callData) {
+            return _this.facade.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.eq, [
+                value,
+                address,
+                callData,
+            ]);
+        };
+        this.lt = function (value, address, callData) {
+            return _this.facade.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.lt, [
+                value,
+                address,
+                callData,
+            ]);
+        };
+        this.gt = function (value, address, callData) {
+            return _this.facade.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.gt, [
+                value,
+                address,
+                callData,
+            ]);
+        };
+        this.nonceEquals = function (makerAddress, makerNonce) {
+            return _this.facade.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.nonceEquals, [makerAddress, makerNonce]);
+        };
+        this.timestampBelow = function (timestamp) {
+            return _this.facade.getContractCallData(limit_order_protocol_model_1.LimitOrderProtocolMethods.timestampBelow, [limit_order_protocol_const_1.ZX + timestamp.toString(16)]);
+        };
+    }
+    return LimitOrderPredicateBuilder;
+}());
+exports.LimitOrderPredicateBuilder = LimitOrderPredicateBuilder;

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

@@ -0,0 +1,18 @@
+export var __esModule: boolean;
+export var PROTOCOL_NAME: string;
+export var PROTOCOL_VERSION: string;
+export var ZX: string;
+export var ZERO_ADDRESS: string;
+export var CALL_RESULTS_PREFIX: string;
+export var EIP712_DOMAIN: {
+    name: string;
+    type: string;
+}[];
+export var ORDER_STRUCTURE: {
+    name: string;
+    type: string;
+}[];
+export var RFQ_ORDER_STRUCTURE: {
+    name: string;
+    type: string;
+}[];

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFQ_ORDER_STRUCTURE = exports.ORDER_STRUCTURE = exports.EIP712_DOMAIN = exports.ERC20_ABI = exports.LIMIT_ORDER_PROTOCOL_ABI = exports.CALL_RESULTS_PREFIX = exports.ZERO_ADDRESS = exports.ZX = exports.PROTOCOL_VERSION = exports.PROTOCOL_NAME = void 0;
+var tslib_1 = require("tslib");
+var LimitOrderProtocol_json_1 = tslib_1.__importDefault(require("./abi/LimitOrderProtocol.json"));
+var ERC20ABI_json_1 = tslib_1.__importDefault(require("./abi/ERC20ABI.json"));
+exports.PROTOCOL_NAME = '1inch Limit Order Protocol';
+exports.PROTOCOL_VERSION = '2';
+exports.ZX = '0x';
+exports.ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+exports.CALL_RESULTS_PREFIX = 'CALL_RESULTS_';
+exports.LIMIT_ORDER_PROTOCOL_ABI = LimitOrderProtocol_json_1.default;
+exports.ERC20_ABI = ERC20ABI_json_1.default;
+exports.EIP712_DOMAIN = [
+    { name: 'name', type: 'string' },
+    { name: 'version', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+    { name: 'verifyingContract', type: 'address' },
+];
+exports.ORDER_STRUCTURE = [
+    { name: 'salt', type: 'uint256' },
+    { name: 'makerAsset', type: 'address' },
+    { name: 'takerAsset', type: 'address' },
+    { name: 'maker', type: 'address' },
+    { name: 'receiver', type: 'address' },
+    { name: 'allowedSender', type: 'address' },
+    { name: 'makingAmount', type: 'uint256' },
+    { name: 'takingAmount', type: 'uint256' },
+    { name: 'makerAssetData', type: 'bytes' },
+    { name: 'takerAssetData', type: 'bytes' },
+    { name: 'getMakerAmount', type: 'bytes' },
+    { name: 'getTakerAmount', type: 'bytes' },
+    { name: 'predicate', type: 'bytes' },
+    { name: 'permit', type: 'bytes' },
+    { name: 'interaction', type: 'bytes' },
+];
+exports.RFQ_ORDER_STRUCTURE = [
+    { name: 'info', type: 'uint256' },
+    { name: 'makerAsset', type: 'address' },
+    { name: 'takerAsset', type: 'address' },
+    { name: 'maker', type: 'address' },
+    { name: 'allowedSender', type: 'address' },
+    { name: 'makingAmount', type: 'uint256' },
+    { name: 'takingAmount', type: 'uint256' },
+];

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

@@ -0,0 +1,26 @@
+export var __esModule: boolean;
+export class LimitOrderProtocolFacade {
+    constructor(contractAddress: any, providerConnector: any);
+    contractAddress: any;
+    providerConnector: any;
+    fillLimitOrder(order: any, signature: any, makerAmount: any, takerAmount: any, thresholdAmount: any): any;
+    fillOrderToWithPermit(params: any): any;
+    fillRFQOrder(order: any, signature: any, makerAmount: any, takerAmount: any): any;
+    cancelLimitOrder(order: any): any;
+    cancelRFQOrder(orderInfo: any): any;
+    nonce(makerAddress: any): any;
+    advanceNonce(count: any): any;
+    increaseNonce(): any;
+    checkPredicate(order: any): any;
+    remaining(orderHash: any): any;
+    simulateCalls(tokens: any, data: any): any;
+    domainSeparator(): any;
+    getContractCallData(methodName: any, methodParams?: any[]): any;
+    parseRemainingResponse(response: any): bignumber_1.BigNumber | null;
+    parseSimulateTransferResponse(response: any): boolean | null;
+    parseSimulateTransferError(error: any): boolean | null;
+    parseContractResponse(response: any): any;
+    isMsgContainsCorrectCode(message: any): boolean | null;
+    stringifyError(error: any): string;
+}
+import bignumber_1 = require("@ethersproject/bignumber");