@1inch/fusion-sdk 2.3.4 → 2.3.6-rc.0

package/dist/cjs/fusion-order/whitelist/whitelist.js

@@ -1,121 +1,265 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Whitelist = void 0;
-const tslib_1 = require("tslib");
-const byte_utils_1 = require("@1inch/byte-utils");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const constants_1 = require("../../constants");
-const time_1 = require("../../utils/time");
-const utils_1 = require("../../utils");
-class Whitelist {
-    constructor(resolvingStartTime, whitelist) {
-        this.resolvingStartTime = resolvingStartTime;
-        this.whitelist = whitelist;
-        (0, assert_1.default)(whitelist.length, 'whitelist can not be empty');
-        whitelist.forEach((w) => {
-            (0, assert_1.default)(w.delay < constants_1.UINT_16_MAX, 'too big diff between timestamps');
-            (0, assert_1.default)(w.delay >= 0n, 'delay can not be negative');
-        });
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Whitelist", {
+    enumerable: true,
+    get: function() {
+        return Whitelist;
     }
-    get length() {
-        return this.whitelist.length;
-    }
-    static decodeFrom(bytes) {
-        const whitelist = [];
-        const resolvingStartTime = BigInt(bytes.nextUint32());
-        const size = BigInt(bytes.nextUint8());
-        for (let i = 0; i < size; i++) {
-            const addressHalf = BigInt(bytes.nextBytes(10))
-                .toString(16)
-                .padStart(20, '0');
-            const delay = BigInt(bytes.nextUint16());
-            whitelist.push({
-                addressHalf,
-                delay
-            });
-        }
-        return new Whitelist(resolvingStartTime, whitelist);
+});
+var _byteutils = require("@1inch/byte-utils");
+var _assert = /*#__PURE__*/ _interop_require_default(require("assert"));
+var _constants = require("../../constants.js");
+var _time = require("../../utils/time.js");
+var _utils = require("../../utils.js");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    static decode(bytes) {
-        return Whitelist.decodeFrom(byte_utils_1.BytesIter.HexString(bytes));
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    static new(resolvingStartTime, whitelist) {
-        let sumDelay = 0n;
-        const _whitelist = whitelist
-            .map((d) => ({
-            addressHalf: d.address.toString().slice(-20),
-            allowFrom: d.allowFrom < resolvingStartTime
-                ? resolvingStartTime
-                : d.allowFrom
-        }))
-            .sort((a, b) => Number(a.allowFrom - b.allowFrom))
-            .map((val) => {
-            const delay = val.allowFrom - resolvingStartTime - sumDelay;
-            sumDelay += delay;
-            return {
-                delay,
-                addressHalf: val.addressHalf
-            };
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
-        return new Whitelist(resolvingStartTime, _whitelist);
+    } else {
+        obj[key] = value;
     }
-    static fromNow(whitelist) {
-        return Whitelist.new((0, time_1.now)(), whitelist);
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var Whitelist = /*#__PURE__*/ function() {
+    "use strict";
+    function Whitelist(resolvingStartTime, whitelist) {
+        _class_call_check(this, Whitelist);
+        _define_property(this, "resolvingStartTime", void 0);
+        _define_property(this, "whitelist", void 0);
+        this.resolvingStartTime = resolvingStartTime;
+        this.whitelist = whitelist;
+        (0, _assert.default)(whitelist.length, 'whitelist can not be empty');
+        whitelist.forEach(function(w) {
+            (0, _assert.default)(w.delay < _constants.UINT_16_MAX, 'too big diff between timestamps');
+            (0, _assert.default)(w.delay >= 0n, 'delay can not be negative');
+        });
     }
-    canExecuteAt(executor, executionTime) {
-        const addressHalf = executor.toString().slice(-20);
-        let allowedFrom = this.resolvingStartTime;
-        for (const whitelist of this.whitelist) {
-            allowedFrom += whitelist.delay;
-            if (addressHalf === whitelist.addressHalf) {
-                return executionTime >= allowedFrom;
+    _create_class(Whitelist, [
+        {
+            key: "length",
+            get: function get() {
+                return this.whitelist.length;
             }
-            else if (executionTime < allowedFrom) {
+        },
+        {
+            key: "canExecuteAt",
+            value: /**
+     * Check whether address allowed to execute order at the given time
+     *
+     * @param executor address of executor
+     * @param executionTime timestamp in sec at which order planning to execute
+     */ function canExecuteAt(executor, executionTime) {
+                var addressHalf = executor.toString().slice(-20);
+                var allowedFrom = this.resolvingStartTime;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this.whitelist[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var whitelist = _step.value;
+                        allowedFrom += whitelist.delay;
+                        if (addressHalf === whitelist.addressHalf) {
+                            return executionTime >= allowedFrom;
+                        } else if (executionTime < allowedFrom) {
+                            return false;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
                 return false;
             }
+        },
+        {
+            key: "isExclusivityPeriod",
+            value: function isExclusivityPeriod() {
+                var time = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : (0, _time.now)();
+                if (this.whitelist.length === 1) {
+                    return true;
+                }
+                if (this.whitelist[0].delay === this.whitelist[1].delay) {
+                    return false;
+                }
+                return time <= this.resolvingStartTime + this.whitelist[1].delay;
+            }
+        },
+        {
+            key: "isExclusiveResolver",
+            value: function isExclusiveResolver(wallet) {
+                var addressHalf = wallet.toString().slice(-20);
+                // only one resolver, so check if it is the passed address
+                if (this.whitelist.length === 1) {
+                    return addressHalf === this.whitelist[0].addressHalf;
+                }
+                // more than 1 address can fill at the same time, no exclusivity
+                if (this.whitelist[0].delay === this.whitelist[1].delay) {
+                    return false;
+                }
+                return addressHalf === this.whitelist[0].addressHalf;
+            }
+        },
+        {
+            key: "isWhitelisted",
+            value: function isWhitelisted(address) {
+                var half = address.lastHalf();
+                return this.whitelist.some(function(w) {
+                    return w.addressHalf === half;
+                });
+            }
+        },
+        {
+            key: "encodeInto",
+            value: function encodeInto() {
+                var builder = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : new _byteutils.BytesBuilder();
+                builder.addUint32(this.resolvingStartTime).addUint8(BigInt(this.whitelist.length));
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    // whitelist data
+                    for(var _iterator = this.whitelist[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var wl = _step.value;
+                        builder.addBytes((0, _utils.add0x)(wl.addressHalf)).addUint16(wl.delay);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return builder;
+            }
+        },
+        {
+            key: "encode",
+            value: /**
+     * Encode whitelist data to 0x prefixed bytes string
+     */ function encode() {
+                return this.encodeInto().asHex();
+            }
+        },
+        {
+            key: "equal",
+            value: function equal(other) {
+                return this.whitelist.length === other.whitelist.length && this.whitelist.every(function(val, i) {
+                    return other.whitelist[i].delay === val.delay && other.whitelist[i].addressHalf === val.addressHalf;
+                });
+            }
         }
-        return false;
-    }
-    isExclusivityPeriod(time = (0, time_1.now)()) {
-        if (this.whitelist.length === 1) {
-            return true;
-        }
-        if (this.whitelist[0].delay === this.whitelist[1].delay) {
-            return false;
-        }
-        return time <= this.resolvingStartTime + this.whitelist[1].delay;
-    }
-    isExclusiveResolver(wallet) {
-        const addressHalf = wallet.toString().slice(-20);
-        if (this.whitelist.length === 1) {
-            return addressHalf === this.whitelist[0].addressHalf;
-        }
-        if (this.whitelist[0].delay === this.whitelist[1].delay) {
-            return false;
-        }
-        return addressHalf === this.whitelist[0].addressHalf;
-    }
-    isWhitelisted(address) {
-        const half = address.lastHalf();
-        return this.whitelist.some((w) => w.addressHalf === half);
-    }
-    encodeInto(builder = new byte_utils_1.BytesBuilder()) {
-        builder
-            .addUint32(this.resolvingStartTime)
-            .addUint8(BigInt(this.whitelist.length));
-        for (const wl of this.whitelist) {
-            builder.addBytes((0, utils_1.add0x)(wl.addressHalf)).addUint16(wl.delay);
+    ], [
+        {
+            key: "decodeFrom",
+            value: /**
+     * Construct `Whitelist` from BytesIter
+     *
+     * @param bytes with 0x prefix in next format:
+     * - uint32 auctionStartTime
+     * - uint8 whitelist size
+     * - (bytes10 last10bytesOfAddress, uint16 auctionDelay) * N whitelist info
+     */ function decodeFrom(bytes) {
+                var whitelist = [];
+                var resolvingStartTime = BigInt(bytes.nextUint32());
+                var size = BigInt(bytes.nextUint8());
+                for(var i = 0; i < size; i++){
+                    var addressHalf = BigInt(bytes.nextBytes(10)).toString(16).padStart(20, '0');
+                    var delay = BigInt(bytes.nextUint16());
+                    whitelist.push({
+                        addressHalf: addressHalf,
+                        delay: delay
+                    });
+                }
+                return new Whitelist(resolvingStartTime, whitelist);
+            }
+        },
+        {
+            key: "decode",
+            value: /**
+     * Construct `Whitelist` from bytes
+     *
+     * @param bytes with 0x prefix
+     * @see decodeFrom
+     */ function decode(bytes) {
+                return Whitelist.decodeFrom(_byteutils.BytesIter.HexString(bytes));
+            }
+        },
+        {
+            key: "new",
+            value: function _new(resolvingStartTime, whitelist) /**
+             * Timestamp in sec at which address can start resolving
+             */ {
+                var sumDelay = 0n;
+                var _whitelist = whitelist.map(function(d) {
+                    return {
+                        addressHalf: d.address.toString().slice(-20),
+                        allowFrom: d.allowFrom < resolvingStartTime ? resolvingStartTime : d.allowFrom
+                    };
+                }).sort(function(a, b) {
+                    return Number(a.allowFrom - b.allowFrom);
+                }).// ASC
+                map(function(val) {
+                    var delay = val.allowFrom - resolvingStartTime - sumDelay;
+                    sumDelay += delay;
+                    return {
+                        delay: delay,
+                        addressHalf: val.addressHalf
+                    };
+                });
+                return new Whitelist(resolvingStartTime, _whitelist);
+            }
+        },
+        {
+            key: "fromNow",
+            value: function fromNow(whitelist) /**
+             * Timestamp in sec at which address can start resolving
+             */ {
+                return Whitelist.new((0, _time.now)(), whitelist);
+            }
         }
-        return builder;
-    }
-    encode() {
-        return this.encodeInto().asHex();
-    }
-    equal(other) {
-        return (this.whitelist.length === other.whitelist.length &&
-            this.whitelist.every((val, i) => other.whitelist[i].delay === val.delay &&
-                other.whitelist[i].addressHalf === val.addressHalf));
-    }
-}
-exports.Whitelist = Whitelist;
-//# sourceMappingURL=whitelist.js.map
+    ]);
+    return Whitelist;
+}();

package/dist/cjs/fusion-order/whitelist/whitelist.spec.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _limitordersdk = require("@1inch/limit-order-sdk");
+var _byteutils = require("@1inch/byte-utils");
+var _whitelist = require("./whitelist.js");
+var _time = require("../../utils/time.js");
+describe('Whitelist', function() {
+    it('should encode/decode', function() {
+        var whitelist = _whitelist.Whitelist.new((0, _time.now)(), [
+            {
+                address: _limitordersdk.Address.fromBigInt(1n),
+                allowFrom: (0, _time.now)() + 10n
+            },
+            {
+                address: _limitordersdk.Address.fromBigInt(_byteutils.UINT_160_MAX),
+                allowFrom: (0, _time.now)() + 20n
+            }
+        ]);
+        expect(_whitelist.Whitelist.decode(whitelist.encode())).toEqual(whitelist);
+    });
+    it('Should generate correct whitelist', function() {
+        var start = 1708117482n;
+        var data = _whitelist.Whitelist.new(start, [
+            {
+                address: _limitordersdk.Address.fromBigInt(2n),
+                allowFrom: start + 1000n
+            },
+            {
+                address: _limitordersdk.Address.ZERO_ADDRESS,
+                allowFrom: start - 10n
+            },
+            // should be set to start
+            {
+                address: _limitordersdk.Address.fromBigInt(1n),
+                allowFrom: start + 10n
+            },
+            {
+                address: _limitordersdk.Address.fromBigInt(3n),
+                allowFrom: start + 10n
+            }
+        ]);
+        expect(data.whitelist).toStrictEqual([
+            {
+                addressHalf: _limitordersdk.Address.ZERO_ADDRESS.toString().slice(-20),
+                delay: 0n
+            },
+            {
+                addressHalf: _limitordersdk.Address.fromBigInt(1n).toString().slice(-20),
+                delay: 10n
+            },
+            {
+                addressHalf: _limitordersdk.Address.fromBigInt(3n).toString().slice(-20),
+                delay: 0n
+            },
+            {
+                addressHalf: _limitordersdk.Address.fromBigInt(2n).toString().slice(-20),
+                delay: 990n
+            }
+        ]);
+        expect(data.canExecuteAt(_limitordersdk.Address.fromBigInt(1n), start + 10n)).toEqual(true);
+        expect(data.canExecuteAt(_limitordersdk.Address.fromBigInt(1n), start + 9n)).toEqual(false);
+        expect(data.canExecuteAt(_limitordersdk.Address.fromBigInt(3n), start + 10n)).toEqual(true);
+        expect(data.canExecuteAt(_limitordersdk.Address.fromBigInt(3n), start + 9n)).toEqual(false);
+        expect(data.canExecuteAt(_limitordersdk.Address.fromBigInt(2n), start + 50n)).toEqual(false);
+    });
+});

package/dist/cjs/index.js

@@ -1,36 +1,92 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrderStatus = exports.Quote = exports.Preset = exports.PresetEnum = exports.QuoterCustomPresetRequest = exports.RelayerRequest = exports.QuoterRequest = exports.MakerTraits = exports.LimitOrderContract = exports.getLimitOrderV4Domain = exports.AmountMode = exports.ExtensionBuilder = exports.TakerTraits = exports.Interaction = exports.getLimitOrderContract = exports.randBigInt = exports.Extension = exports.Address = void 0;
-const tslib_1 = require("tslib");
-var limit_order_sdk_1 = require("@1inch/limit-order-sdk");
-Object.defineProperty(exports, "Address", { enumerable: true, get: function () { return limit_order_sdk_1.Address; } });
-Object.defineProperty(exports, "Extension", { enumerable: true, get: function () { return limit_order_sdk_1.Extension; } });
-Object.defineProperty(exports, "randBigInt", { enumerable: true, get: function () { return limit_order_sdk_1.randBigInt; } });
-Object.defineProperty(exports, "getLimitOrderContract", { enumerable: true, get: function () { return limit_order_sdk_1.getLimitOrderContract; } });
-Object.defineProperty(exports, "Interaction", { enumerable: true, get: function () { return limit_order_sdk_1.Interaction; } });
-Object.defineProperty(exports, "TakerTraits", { enumerable: true, get: function () { return limit_order_sdk_1.TakerTraits; } });
-Object.defineProperty(exports, "ExtensionBuilder", { enumerable: true, get: function () { return limit_order_sdk_1.ExtensionBuilder; } });
-Object.defineProperty(exports, "AmountMode", { enumerable: true, get: function () { return limit_order_sdk_1.AmountMode; } });
-Object.defineProperty(exports, "getLimitOrderV4Domain", { enumerable: true, get: function () { return limit_order_sdk_1.getLimitOrderV4Domain; } });
-Object.defineProperty(exports, "LimitOrderContract", { enumerable: true, get: function () { return limit_order_sdk_1.LimitOrderContract; } });
-Object.defineProperty(exports, "MakerTraits", { enumerable: true, get: function () { return limit_order_sdk_1.MakerTraits; } });
-tslib_1.__exportStar(require("./fusion-order/index"), exports);
-tslib_1.__exportStar(require("./amount-calculator/"), exports);
-tslib_1.__exportStar(require("./connector/index"), exports);
-tslib_1.__exportStar(require("./sdk/index"), exports);
-tslib_1.__exportStar(require("./constants"), exports);
-tslib_1.__exportStar(require("./utils"), exports);
-tslib_1.__exportStar(require("./utils/amounts"), exports);
-tslib_1.__exportStar(require("./utils/time"), exports);
-tslib_1.__exportStar(require("./validations"), exports);
-tslib_1.__exportStar(require("./ws-api"), exports);
-tslib_1.__exportStar(require("./errors"), exports);
-var index_1 = require("./api/index");
-Object.defineProperty(exports, "QuoterRequest", { enumerable: true, get: function () { return index_1.QuoterRequest; } });
-Object.defineProperty(exports, "RelayerRequest", { enumerable: true, get: function () { return index_1.RelayerRequest; } });
-Object.defineProperty(exports, "QuoterCustomPresetRequest", { enumerable: true, get: function () { return index_1.QuoterCustomPresetRequest; } });
-Object.defineProperty(exports, "PresetEnum", { enumerable: true, get: function () { return index_1.PresetEnum; } });
-Object.defineProperty(exports, "Preset", { enumerable: true, get: function () { return index_1.Preset; } });
-Object.defineProperty(exports, "Quote", { enumerable: true, get: function () { return index_1.Quote; } });
-Object.defineProperty(exports, "OrderStatus", { enumerable: true, get: function () { return index_1.OrderStatus; } });
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Address: function() {
+        return _limitordersdk.Address;
+    },
+    AmountMode: function() {
+        return _limitordersdk.AmountMode;
+    },
+    Extension: function() {
+        return _limitordersdk.Extension;
+    },
+    ExtensionBuilder: function() {
+        return _limitordersdk.ExtensionBuilder;
+    },
+    Interaction: function() {
+        return _limitordersdk.Interaction;
+    },
+    LimitOrderContract: function() {
+        return _limitordersdk.LimitOrderContract;
+    },
+    MakerTraits: function() {
+        return _limitordersdk.MakerTraits;
+    },
+    OrderStatus: function() {
+        return _index.OrderStatus;
+    },
+    Preset: function() {
+        return _index.Preset;
+    },
+    PresetEnum: function() {
+        return _index.PresetEnum;
+    },
+    Quote: function() {
+        return _index.Quote;
+    },
+    QuoterCustomPresetRequest: function() {
+        return _index.QuoterCustomPresetRequest;
+    },
+    QuoterRequest: function() {
+        return _index.QuoterRequest;
+    },
+    RelayerRequest: function() {
+        return _index.RelayerRequest;
+    },
+    TakerTraits: function() {
+        return _limitordersdk.TakerTraits;
+    },
+    getLimitOrderContract: function() {
+        return _limitordersdk.getLimitOrderContract;
+    },
+    getLimitOrderV4Domain: function() {
+        return _limitordersdk.getLimitOrderV4Domain;
+    },
+    randBigInt: function() {
+        return _limitordersdk.randBigInt;
+    }
+});
+var _limitordersdk = require("@1inch/limit-order-sdk");
+_export_star(require("./fusion-order/index.js"), exports);
+_export_star(require("./amount-calculator//index.js"), exports);
+_export_star(require("./connector/index.js"), exports);
+_export_star(require("./sdk/index.js"), exports);
+_export_star(require("./constants.js"), exports);
+_export_star(require("./utils.js"), exports);
+_export_star(require("./utils/amounts.js"), exports);
+_export_star(require("./utils/time.js"), exports);
+_export_star(require("./validations.js"), exports);
+_export_star(require("./ws-api/index.js"), exports);
+_export_star(require("./errors.js"), exports);
+var _index = require("./api/index.js");
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}