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

package/dist/esm/connector/ws/websocket-client.connector.js

@@ -1,82 +1,156 @@
+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 WebSocket from 'ws';
-export class WebsocketClient {
-    constructor(config) {
+export var WebsocketClient = /*#__PURE__*/ function() {
+    "use strict";
+    function WebsocketClient(config) {
+        _class_call_check(this, WebsocketClient);
+        _define_property(this, "ws", void 0);
+        _define_property(this, "url", void 0);
+        _define_property(this, "initialized", void 0);
+        _define_property(this, "authKey", void 0);
         this.url = config.url;
         this.authKey = config.authKey;
-        const lazyInit = config.lazyInit || false;
+        var lazyInit = config.lazyInit || false;
         if (!lazyInit) {
             this.initialized = true;
-            this.ws = new WebSocket(this.url, this.authKey
-                ? {
-                    headers: {
-                        Authorization: `Bearer ${this.authKey}`
-                    }
+            this.ws = new WebSocket(this.url, this.authKey ? {
+                headers: {
+                    Authorization: "Bearer ".concat(this.authKey)
                 }
-                : undefined);
+            } : undefined);
             return;
         }
         this.initialized = false;
     }
-    init() {
-        if (this.initialized) {
-            throw new Error('WebSocket is already initialized');
-        }
-        this.initialized = true;
-        this.ws = new WebSocket(this.url, this.authKey
-            ? {
-                headers: {
-                    Authorization: `Bearer ${this.authKey}`
+    _create_class(WebsocketClient, [
+        {
+            key: "init",
+            value: function init() {
+                if (this.initialized) {
+                    throw new Error('WebSocket is already initialized');
+                }
+                // @ts-expect-error hack for readonly property
+                this.initialized = true;
+                // @ts-expect-error hack for readonly property
+                this.ws = new WebSocket(this.url, this.authKey ? {
+                    headers: {
+                        Authorization: "Bearer ".concat(this.authKey)
+                    }
+                } : undefined);
+            }
+        },
+        {
+            key: "on",
+            value: function on(event, cb) {
+                this.checkInitialized();
+                this.ws.on(event, cb);
+            }
+        },
+        {
+            key: "off",
+            value: function off(event, cb) {
+                this.checkInitialized();
+                this.ws.off(event, cb);
+            }
+        },
+        {
+            key: "onOpen",
+            value: function onOpen(cb) {
+                this.on('open', cb);
+            }
+        },
+        {
+            key: "send",
+            value: function send(message) {
+                this.checkInitialized();
+                var serialized = JSON.stringify(message);
+                this.ws.send(serialized);
+            }
+        },
+        {
+            key: "onMessage",
+            value: function onMessage(cb) {
+                this.on('message', function(data) {
+                    var parsedData = JSON.parse(data);
+                    cb(parsedData);
+                });
+            }
+        },
+        {
+            key: "ping",
+            value: function ping() {
+                this.ws.ping();
+            }
+        },
+        {
+            key: "onPong",
+            value: function onPong(cb) {
+                this.on('pong', function() {
+                    cb();
+                });
+            }
+        },
+        {
+            key: "onClose",
+            value: function onClose(cb) {
+                this.on('close', cb);
+            }
+        },
+        {
+            key: "onError",
+            value: function onError(cb) {
+                this.on('error', cb);
+            }
+        },
+        {
+            key: "close",
+            value: function close() {
+                this.checkInitialized();
+                this.ws.close();
+            }
+        },
+        {
+            key: "checkInitialized",
+            value: function checkInitialized() {
+                if (!this.initialized) {
+                    throwInitError();
                 }
             }
-            : undefined);
-    }
-    on(event, cb) {
-        this.checkInitialized();
-        this.ws.on(event, cb);
-    }
-    off(event, cb) {
-        this.checkInitialized();
-        this.ws.off(event, cb);
-    }
-    onOpen(cb) {
-        this.on('open', cb);
-    }
-    send(message) {
-        this.checkInitialized();
-        const serialized = JSON.stringify(message);
-        this.ws.send(serialized);
-    }
-    onMessage(cb) {
-        this.on('message', (data) => {
-            const parsedData = JSON.parse(data);
-            cb(parsedData);
-        });
-    }
-    ping() {
-        this.ws.ping();
-    }
-    onPong(cb) {
-        this.on('pong', () => {
-            cb();
-        });
-    }
-    onClose(cb) {
-        this.on('close', cb);
-    }
-    onError(cb) {
-        this.on('error', cb);
-    }
-    close() {
-        this.checkInitialized();
-        this.ws.close();
-    }
-    checkInitialized() {
-        if (!this.initialized) {
-            throwInitError();
         }
-    }
-}
+    ]);
+    return WebsocketClient;
+}();
 function throwInitError() {
     throw new Error('WebSocket is not initialized. Call init() first.');
 }
-//# sourceMappingURL=websocket-client.connector.js.map

package/dist/esm/connector/ws/websocket-provider.connector.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=websocket-provider.connector.js.map
+export { };

package/dist/esm/constants.js

@@ -1,6 +1,5 @@
-export const ZX = '0x';
-export var NetworkEnum;
-(function (NetworkEnum) {
+export var ZX = '0x';
+export var NetworkEnum = /*#__PURE__*/ function(NetworkEnum) {
     NetworkEnum[NetworkEnum["ETHEREUM"] = 1] = "ETHEREUM";
     NetworkEnum[NetworkEnum["POLYGON"] = 137] = "POLYGON";
     NetworkEnum[NetworkEnum["ZKSYNC"] = 324] = "ZKSYNC";
@@ -14,13 +13,13 @@ export var NetworkEnum;
     NetworkEnum[NetworkEnum["LINEA"] = 59144] = "LINEA";
     NetworkEnum[NetworkEnum["SONIC"] = 146] = "SONIC";
     NetworkEnum[NetworkEnum["UNICHAIN"] = 130] = "UNICHAIN";
-})(NetworkEnum || (NetworkEnum = {}));
-export const ONE_INCH_LIMIT_ORDER_V4 = '0x111111125421ca6dc452d289314280a0f8842a65';
-export const UINT_160_MAX = (1n << 160n) - 1n;
-export const UINT_16_MAX = (1n << 16n) - 1n;
-export const UINT_80_MAX = (1n << 80n) - 1n;
-export const UINT_40_MAX = (1n << 40n) - 1n;
-export const UINT_32_MAX = (1n << 32n) - 1n;
-export const UINT_24_MAX = (1n << 24n) - 1n;
-export const UINT_256_MAX = (1n << 256n) - 1n;
-//# sourceMappingURL=constants.js.map
+    return NetworkEnum;
+}({});
+export var ONE_INCH_LIMIT_ORDER_V4 = '0x111111125421ca6dc452d289314280a0f8842a65';
+export var UINT_160_MAX = (1n << 160n) - 1n;
+export var UINT_16_MAX = (1n << 16n) - 1n;
+export var UINT_80_MAX = (1n << 80n) - 1n;
+export var UINT_40_MAX = (1n << 40n) - 1n;
+export var UINT_32_MAX = (1n << 32n) - 1n;
+export var UINT_24_MAX = (1n << 24n) - 1n;
+export var UINT_256_MAX = (1n << 256n) - 1n;

package/dist/esm/errors.js

@@ -1,6 +1,116 @@
-export class AuthError extends Error {
-    constructor() {
-        super('Auth error, please use token from https://portal.1inch.dev/');
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
+    return self;
 }
-//# sourceMappingURL=errors.js.map
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+export var AuthError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(AuthError, Error1);
+    function AuthError() {
+        _class_call_check(this, AuthError);
+        return _call_super(this, AuthError, [
+            'Auth error, please use token from https://portal.1inch.dev/'
+        ]);
+    }
+    return AuthError;
+}(_wrap_native_super(Error));

package/dist/esm/fusion-order/README.md

@@ -0,0 +1,58 @@
+## FusionOrder
+
+**Example:**
+
+```typescript
+import {AuctionDetails, FusionOrder, Whitelist, now} from '@1inch/fusion-sdk'
+
+const extensionContract = new Address('0x8273f37417da37c4a6c3995e82cf442f87a25d9c')
+const resolvingStartAt = now()
+
+const order = FusionOrder.new(
+    extensionContract,
+    {
+        makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+        takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+        makingAmount: 1000000000000000000n,
+        takingAmount: 1420000000n,
+        maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa'),
+        salt: 10n
+    },
+    {
+        auction: new AuctionDetails({
+            duration: 180n,
+            startTime: 1673548149n,
+            initialRateBump: 50000,
+            points: [
+                {
+                    coefficient: 20000,
+                    delay: 12
+                }
+            ]
+        }),
+        whitelist: Whitelist.new(resolvingStartAt, [
+            {
+                address: new Address(
+                    '0x00000000219ab540356cbb839cbe05303d7705fa'
+                ),
+                delay: 0n
+            }
+        ])
+    }
+)
+
+const extension = order.extension.encode() // => 0x...
+const builtOrder = order.build()
+/* => {
+            maker: '0x00000000219ab540356cbb839cbe05303d7705fa',
+            makerAsset: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+            makingAmount: '1000000000000000000',
+            receiver: '0x0000000000000000000000000000000000000000',
+            takerAsset: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+            takingAmount: '1420000000',
+            makerTraits:
+                '29852648006495581632639394572552351243421169944806257724550573036760110989312',
+            salt: '14832508939800728556409473652845244531014097925085'
+        }
+*/
+```

package/dist/esm/fusion-order/auction-details/README.md

@@ -0,0 +1,85 @@
+## AuctionDetails
+
+**Description:** encapsulates:
+
+-   auction start time
+-   duration of an auction
+-   initial rate bump
+-   auction price curve
+-   gas cost
+
+**Examples:**
+
+```typescript
+import {AuctionDetails} from '@1inch/fusion-sdk'
+
+const details = new AuctionDetails({
+    duration: 180n, // in seconds,
+    startTime: 1673548149n, // unix timestamp (in sec),
+    /**
+     * It defined as a ratio of startTakingAmount to endTakingAmount. 10_000_000 means 100%
+     *
+     * @see `AuctionCalculator.calcInitialRateBump`
+     */
+    initialRateBump: 50000,
+    /**
+     * Points which define price curve.
+     * Each point contains `delay` - relative to previous point (auction start for first)
+     * and `coefficient` - rate bump for `auctionEndAmount` (10000000 = 100%)
+     *
+     * y(rate) ▲
+     *         │
+     *    5000 │\
+     *         │ \
+     *         │  \
+     *    4000 │   \───────
+     *         │           \
+     *         │            \
+     *    3000 │             \
+     *         │              \
+     *         └─────────────────────────►
+     *         0   10     20  end   x(time)
+     */
+    points: [
+        {
+            delay: 10, // relative to auction start time
+            coefficient: 40000
+        },
+
+        {
+            delay: 10, // relative to previous point
+            coefficient: 40000
+        }
+    ],
+    /**
+     * Allows to ajust estimated gas costs to real onchain gas costs
+     */
+    gasCost: {
+        /**
+         * Rate bump to cover gas price. 
+         * It defined as a ratio of gasCostInToToken to endTakingAmount. 10_000_000 means 100%
+         * 
+         * @see `AuctionCalculator.calcGasBumpEstimate`
+         */
+        gasBumpEstimate: 10_000n,
+        /**
+         * Gas price at estimation time. 1000 means 1 Gwei
+         */
+        gasPriceEstimate: 1000n
+    }
+})
+
+details.encode()
+// #=> '0x63c051750000b400c350009c40000a009c40000a'
+```
+
+### static AuctionDetails.decode
+
+**Arguments:** string
+
+```typescript
+import {AuctionDetails} from '@1inch/fusion-sdk'
+
+const salt = AuctionDetails.decode('0x63c051750000b400c350009c40000a009c40000a')
+// #=> AuctionDetails
+```