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

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

@@ -1,116 +1,250 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+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);
+    }
+}
+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
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 import { BytesBuilder, BytesIter } from '@1inch/byte-utils';
 import assert from 'assert';
-import { UINT_16_MAX } from '../../constants';
-import { now } from '../../utils/time';
-import { add0x } from '../../utils';
-export class Whitelist {
-    constructor(resolvingStartTime, whitelist) {
+import { UINT_16_MAX } from '../../constants.js';
+import { now } from '../../utils/time.js';
+import { add0x } from '../../utils.js';
+export 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;
         assert(whitelist.length, 'whitelist can not be empty');
-        whitelist.forEach((w) => {
+        whitelist.forEach(function(w) {
             assert(w.delay < UINT_16_MAX, 'too big diff between timestamps');
             assert(w.delay >= 0n, 'delay can not be negative');
         });
     }
-    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);
-    }
-    static decode(bytes) {
-        return Whitelist.decodeFrom(BytesIter.HexString(bytes));
-    }
-    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
-            };
-        });
-        return new Whitelist(resolvingStartTime, _whitelist);
-    }
-    static fromNow(whitelist) {
-        return Whitelist.new(now(), whitelist);
-    }
-    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] : 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 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(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 = 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 BytesBuilder()) {
-        builder
-            .addUint32(this.resolvingStartTime)
-            .addUint8(BigInt(this.whitelist.length));
-        for (const wl of this.whitelist) {
-            builder.addBytes(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(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(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));
-    }
-}
-//# sourceMappingURL=whitelist.js.map
+    ]);
+    return Whitelist;
+}();

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

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

package/dist/esm/index.js

@@ -1,14 +1,13 @@
 export { Address, Extension, randBigInt, getLimitOrderContract, Interaction, TakerTraits, ExtensionBuilder, AmountMode, getLimitOrderV4Domain, LimitOrderContract, MakerTraits } from '@1inch/limit-order-sdk';
-export * from './fusion-order/index';
-export * from './amount-calculator/';
-export * from './connector/index';
-export * from './sdk/index';
-export * from './constants';
-export * from './utils';
-export * from './utils/amounts';
-export * from './utils/time';
-export * from './validations';
-export * from './ws-api';
-export * from './errors';
-export { QuoterRequest, RelayerRequest, QuoterCustomPresetRequest, PresetEnum, Preset, Quote, OrderStatus } from './api/index';
-//# sourceMappingURL=index.js.map
+export * from './fusion-order/index.js';
+export * from './amount-calculator//index.js';
+export * from './connector/index.js';
+export * from './sdk/index.js';
+export * from './constants.js';
+export * from './utils.js';
+export * from './utils/amounts.js';
+export * from './utils/time.js';
+export * from './validations.js';
+export * from './ws-api/index.js';
+export * from './errors.js';
+export { QuoterRequest, RelayerRequest, QuoterCustomPresetRequest, PresetEnum, Preset, Quote, OrderStatus } from './api/index.js';

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"name":"@1inch/fusion-sdk","version":"2.3.6-rc.0","type":"module"}