ccxt 4.1.45 → 4.1.46

package/dist/cjs/src/pro/bybit.js

@@ -22,8 +22,8 @@ class bybit extends bybit$1 {
                 'watchTicker': true,
                 'watchTickers': true,
                 'watchTrades': true,
+                'watchPositions': true,
                 'watchTradesForSymbols': true,
-                'watchPosition': undefined,
             },
             'urls': {
                 'api': {
@@ -67,6 +67,10 @@ class bybit extends bybit$1 {
                 'watchTicker': {
                     'name': 'tickers', // 'tickers' for 24hr statistical ticker or 'tickers_lt' for leverage token ticker
                 },
+                'watchPositions': {
+                    'fetchPositionsSnapshot': true,
+                    'awaitPositionsSnapshot': true, // whether to wait for the positions snapshot before providing updates
+                },
                 'spot': {
                     'timeframes': {
                         '1m': '1m',
@@ -180,7 +184,7 @@ class bybit extends bybit$1 {
         }
         topic += '.' + market['id'];
         const topics = [topic];
-        return await this.watchTopics(url, messageHash, topics, params);
+        return await this.watchTopics(url, messageHash, topics, messageHash, params);
     }
     async watchTickers(symbols = undefined, params = {}) {
         /**
@@ -377,7 +381,7 @@ class bybit extends bybit$1 {
         const timeframeId = this.safeString(this.timeframes, timeframe, timeframe);
         const topics = ['kline.' + timeframeId + '.' + market['id']];
         const messageHash = 'kline' + ':' + timeframeId + ':' + symbol;
-        ohlcv = await this.watchTopics(url, messageHash, topics, params);
+        ohlcv = await this.watchTopics(url, messageHash, topics, messageHash, params);
         if (this.newUpdates) {
             limit = ohlcv.getLimit(symbol, limit);
         }
@@ -534,7 +538,7 @@ class bybit extends bybit$1 {
             }
         }
         const topics = ['orderbook.' + limit.toString() + '.' + market['id']];
-        const orderbook = await this.watchTopics(url, messageHash, topics, params);
+        const orderbook = await this.watchTopics(url, messageHash, topics, messageHash, params);
         return orderbook.limit();
     }
     async watchOrderBookForSymbols(symbols, limit = undefined, params = {}) {
@@ -672,7 +676,7 @@ class bybit extends bybit$1 {
         params = this.cleanParams(params);
         const messageHash = 'trade:' + symbol;
         const topic = 'publicTrade.' + market['id'];
-        const trades = await this.watchTopics(url, messageHash, [topic], params);
+        const trades = await this.watchTopics(url, messageHash, [topic], messageHash, params);
         if (this.newUpdates) {
             limit = trades.getLimit(symbol, limit);
         }
@@ -868,7 +872,7 @@ class bybit extends bybit$1 {
             'usdc': 'user.openapi.perp.trade',
         };
         const topic = this.safeValue(topicByMarket, this.getPrivateType(url));
-        const trades = await this.watchTopics(url, messageHash, [topic], params);
+        const trades = await this.watchTopics(url, messageHash, [topic], messageHash, params);
         if (this.newUpdates) {
             limit = trades.getLimit(symbol, limit);
         }
@@ -966,6 +970,145 @@ class bybit extends bybit$1 {
         const messageHash = 'myTrades';
         client.resolve(trades, messageHash);
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#watchPositions
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/private/position
+         * @description watch all open positions
+         * @param {[string]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the bybit api endpoint
+         * @returns {[object]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        await this.loadMarkets();
+        const method = 'watchPositions';
+        let messageHash = '';
+        if (!this.isEmpty(symbols)) {
+            symbols = this.marketSymbols(symbols);
+            messageHash = '::' + symbols.join(',');
+        }
+        const firstSymbol = this.safeString(symbols, 0);
+        const url = this.getUrlByMarketType(firstSymbol, true, method, params);
+        messageHash = 'positions' + messageHash;
+        const client = this.client(url);
+        await this.authenticate(url);
+        this.setPositionsCache(client, symbols);
+        const cache = this.positions;
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        if (fetchPositionsSnapshot && awaitPositionsSnapshot && cache === undefined) {
+            const snapshot = await client.future('fetchPositionsSnapshot');
+            return this.filterBySymbolsSinceLimit(snapshot, symbols, since, limit, true);
+        }
+        const topics = ['position'];
+        const newPositions = await this.watchTopics(url, messageHash, topics, 'position', params);
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(cache, symbols, since, limit, true);
+    }
+    setPositionsCache(client, symbols = undefined) {
+        if (this.positions !== undefined) {
+            return this.positions;
+        }
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
+        if (fetchPositionsSnapshot) {
+            const messageHash = 'fetchPositionsSnapshot';
+            if (!(messageHash in client.futures)) {
+                client.future(messageHash);
+                this.spawn(this.loadPositionsSnapshot, client, messageHash);
+            }
+        }
+        else {
+            this.positions = new Cache.ArrayCacheBySymbolBySide();
+        }
+    }
+    async loadPositionsSnapshot(client, messageHash) {
+        // as only one ws channel gives positions for all types, for snapshot must load all positions
+        const fetchFunctions = [
+            this.fetchPositions(undefined, { 'type': 'swap', 'subType': 'linear' }),
+            this.fetchPositions(undefined, { 'type': 'swap', 'subType': 'inverse' }),
+        ];
+        const promises = await Promise.all(fetchFunctions);
+        this.positions = new Cache.ArrayCacheBySymbolBySide();
+        const cache = this.positions;
+        for (let i = 0; i < promises.length; i++) {
+            const positions = promises[i];
+            for (let ii = 0; ii < positions.length; ii++) {
+                const position = positions[ii];
+                cache.append(position);
+            }
+        }
+        // don't remove the future from the .futures cache
+        const future = client.futures[messageHash];
+        future.resolve(cache);
+        client.resolve(cache, 'position');
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        topic: 'position',
+        //        id: '504b2671629b08e3c4f6960382a59363:3bc4028023786545:0:01',
+        //        creationTime: 1694566055295,
+        //        data: [{
+        //            bustPrice: '15.00',
+        //            category: 'inverse',
+        //            createdTime: '1670083436351',
+        //            cumRealisedPnl: '0.00011988',
+        //            entryPrice: '19358.58553268',
+        //            leverage: '10',
+        //            liqPrice: '15.00',
+        //            markPrice: '25924.00',
+        //            positionBalance: '0.0000156',
+        //            positionIdx: 0,
+        //            positionMM: '0.001',
+        //            positionIM: '0.0000015497',
+        //            positionStatus: 'Normal',
+        //            positionValue: '0.00015497',
+        //            riskId: 1,
+        //            riskLimitValue: '150',
+        //            side: 'Buy',
+        //            size: '3',
+        //            stopLoss: '0.00',
+        //            symbol: 'BTCUSD',
+        //            takeProfit: '0.00',
+        //            tpslMode: 'Full',
+        //            tradeMode: 0,
+        //            autoAddMargin: 1,
+        //            trailingStop: '0.00',
+        //            unrealisedPnl: '0.00003925',
+        //            updatedTime: '1694566055293',
+        //            adlRankIndicator: 3
+        //        }]
+        //    }
+        //
+        // each account is connected to a different endpoint
+        // and has exactly one subscriptionhash which is the account type
+        if (this.positions === undefined) {
+            this.positions = new Cache.ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions;
+        const newPositions = [];
+        const rawPositions = this.safeValue(message, 'data', []);
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parsePosition(rawPosition);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, 'positions::');
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const parts = messageHash.split('::');
+            const symbolsString = parts[1];
+            const symbols = symbolsString.split(',');
+            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
+            if (!this.isEmpty(positions)) {
+                client.resolve(positions, messageHash);
+            }
+        }
+        client.resolve(newPositions, 'positions');
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -993,7 +1136,7 @@ class bybit extends bybit$1 {
             'usdc': ['user.openapi.perp.order'],
         };
         const topics = this.safeValue(topicsByMarket, this.getPrivateType(url));
-        const orders = await this.watchTopics(url, messageHash, topics, params);
+        const orders = await this.watchTopics(url, messageHash, topics, messageHash, params);
         if (this.newUpdates) {
             limit = orders.getLimit(symbol, limit);
         }
@@ -1310,7 +1453,7 @@ class bybit extends bybit$1 {
             }
         }
         const topics = [this.safeValue(topicByMarket, this.getPrivateType(url))];
-        return await this.watchTopics(url, messageHash, topics, params);
+        return await this.watchTopics(url, messageHash, topics, messageHash, params);
     }
     handleBalance(client, message) {
         //
@@ -1548,14 +1691,14 @@ class bybit extends bybit$1 {
             this.balance[code] = account;
         }
     }
-    async watchTopics(url, messageHash, topics = [], params = {}) {
+    async watchTopics(url, messageHash, topics, subscriptionHash, params = {}) {
         const request = {
             'op': 'subscribe',
             'req_id': this.requestId(),
             'args': topics,
         };
         const message = this.extend(request, params);
-        return await this.watch(url, messageHash, message, messageHash);
+        return await this.watch(url, messageHash, message, subscriptionHash);
     }
     async authenticate(url, params = {}) {
         this.checkRequiredCredentials();
@@ -1682,6 +1825,7 @@ class bybit extends bybit$1 {
             'execution': this.handleMyTrades,
             'ticketInfo': this.handleMyTrades,
             'user.openapi.perp.trade': this.handleMyTrades,
+            'position': this.handlePositions,
         };
         const exacMethod = this.safeValue(methods, topic);
         if (exacMethod !== undefined) {

package/dist/cjs/src/pro/cryptocom.js

@@ -22,6 +22,7 @@ class cryptocom extends cryptocom$1 {
                 'watchOrderBookForSymbols': true,
                 'watchOrders': true,
                 'watchOHLCV': true,
+                'watchPositions': true,
                 'createOrderWs': true,
                 'cancelOrderWs': true,
                 'cancelAllOrders': true,
@@ -38,7 +39,12 @@ class cryptocom extends cryptocom$1 {
                     'private': 'wss://uat-stream.3ona.co/exchange/v1/user',
                 },
             },
-            'options': {},
+            'options': {
+                'watchPositions': {
+                    'fetchPositionsSnapshot': true,
+                    'awaitPositionsSnapshot': true, // whether to wait for the positions snapshot before providing updates
+                },
+            },
             'streaming': {},
         });
     }
@@ -447,6 +453,129 @@ class cryptocom extends cryptocom$1 {
             client.resolve(stored, 'user.order');
         }
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name cryptocom#watchPositions
+         * @description watch all open positions
+         * @see https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#user-position_balance
+         * @param {[string]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the cryptocom api endpoint
+         * @returns {[object]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        const url = this.urls['api']['ws']['private'];
+        const id = this.nonce();
+        const request = {
+            'method': 'subscribe',
+            'params': {
+                'channels': ['user.position_balance'],
+            },
+            'nonce': id,
+        };
+        let messageHash = 'positions';
+        symbols = this.marketSymbols(symbols);
+        if (!this.isEmpty(symbols)) {
+            messageHash = '::' + symbols.join(',');
+        }
+        const client = this.client(url);
+        this.setPositionsCache(client, symbols);
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        if (fetchPositionsSnapshot && awaitPositionsSnapshot && this.positions === undefined) {
+            const snapshot = await client.future('fetchPositionsSnapshot');
+            return this.filterBySymbolsSinceLimit(snapshot, symbols, since, limit, true);
+        }
+        const newPositions = await this.watch(url, messageHash, this.extend(request, params));
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+    }
+    setPositionsCache(client, type, symbols = undefined) {
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', false);
+        if (fetchPositionsSnapshot) {
+            const messageHash = 'fetchPositionsSnapshot';
+            if (!(messageHash in client.futures)) {
+                client.future(messageHash);
+                this.spawn(this.loadPositionsSnapshot, client, messageHash);
+            }
+        }
+        else {
+            this.positions = new Cache.ArrayCacheBySymbolBySide();
+        }
+    }
+    async loadPositionsSnapshot(client, messageHash) {
+        const positions = await this.fetchPositions();
+        this.positions = new Cache.ArrayCacheBySymbolBySide();
+        const cache = this.positions;
+        for (let i = 0; i < positions.length; i++) {
+            const position = positions[i];
+            const contracts = this.safeNumber(position, 'contracts', 0);
+            if (contracts > 0) {
+                cache.append(position);
+            }
+        }
+        // don't remove the future from the .futures cache
+        const future = client.futures[messageHash];
+        future.resolve(cache);
+        client.resolve(cache, 'positions');
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        subscription: "user.position_balance",
+        //        channel: "user.position_balance",
+        //        data: [{
+        //            balances: [{
+        //                instrument_name: "USD",
+        //                quantity: "8.9979961950886",
+        //                update_timestamp_ms: 1695598760597,
+        //            }],
+        //            positions: [{
+        //                account_id: "96a0edb1-afb5-4c7c-af89-5cb610319e2c",
+        //                instrument_name: "LTCUSD-PERP",
+        //                type: "PERPETUAL_SWAP",
+        //                quantity: "1.8",
+        //                cost: "114.766",
+        //                open_position_pnl: "-0.0216206",
+        //                session_pnl: "0.00962994",
+        //                update_timestamp_ms: 1695598760597,
+        //                open_pos_cost: "114.766",
+        //            }],
+        //        }],
+        //    }
+        //
+        // each account is connected to a different endpoint
+        // and has exactly one subscriptionhash which is the account type
+        const data = this.safeValue(message, 'data', []);
+        const firstData = this.safeValue(data, 0, {});
+        const rawPositions = this.safeValue(firstData, 'positions', []);
+        if (this.positions === undefined) {
+            this.positions = new Cache.ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions;
+        const newPositions = [];
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parsePosition(rawPosition);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, 'positions::');
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const parts = messageHash.split('::');
+            const symbolsString = parts[1];
+            const symbols = symbolsString.split(',');
+            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
+            if (!this.isEmpty(positions)) {
+                client.resolve(positions, messageHash);
+            }
+        }
+        client.resolve(newPositions, 'positions');
+    }
     async watchBalance(params = {}) {
         /**
          * @method
@@ -713,6 +842,7 @@ class cryptocom extends cryptocom$1 {
             'user.order': this.handleOrders,
             'user.trade': this.handleTrades,
             'user.balance': this.handleBalance,
+            'user.position_balance': this.handlePositions,
         };
         const result = this.safeValue2(message, 'result', 'info');
         const channel = this.safeString(result, 'channel');

package/dist/cjs/src/pro/gate.js

@@ -21,6 +21,7 @@ class gate extends gate$1 {
                 'watchOHLCV': true,
                 'watchBalance': true,
                 'watchOrders': true,
+                'watchPositions': true,
             },
             'urls': {
                 'api': {
@@ -72,6 +73,10 @@ class gate extends gate$1 {
                     'settle': 'usdt',
                     'spot': 'spot.balances', // spot.margin_balances, spot.funding_balances or spot.cross_balances
                 },
+                'watchPositions': {
+                    'fetchPositionsSnapshot': true,
+                    'awaitPositionsSnapshot': true, // whether to wait for the positions snapshot before providing updates
+                },
             },
             'exceptions': {
                 'ws': {
@@ -750,6 +755,145 @@ class gate extends gate$1 {
         this.balance = this.safeBalance(this.balance);
         client.resolve(this.balance, messageHash);
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#watchPositions
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#positions-subscription
+         * @see https://www.gate.io/docs/developers/delivery/ws/en/#positions-subscription
+         * @see https://www.gate.io/docs/developers/options/ws/en/#positions-channel
+         * @description watch all open positions
+         * @param {[string]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the gate api endpoint
+         * @returns {[object]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        await this.loadMarkets();
+        let market = undefined;
+        symbols = this.marketSymbols(symbols);
+        const payload = ['!' + 'all'];
+        if (!this.isEmpty(symbols)) {
+            market = this.getMarketFromSymbols(symbols);
+        }
+        let type = undefined;
+        let query = undefined;
+        [type, query] = this.handleMarketTypeAndParams('watchPositions', market, params);
+        if (type === 'spot') {
+            type = 'swap';
+        }
+        const typeId = this.getSupportedMapping(type, {
+            'future': 'futures',
+            'swap': 'futures',
+            'option': 'options',
+        });
+        let messageHash = type + ':positions';
+        if (!this.isEmpty(symbols)) {
+            messageHash += '::' + symbols.join(',');
+        }
+        const channel = typeId + '.positions';
+        let subType = undefined;
+        [subType, query] = this.handleSubTypeAndParams('watchPositions', market, query);
+        const isInverse = (subType === 'inverse');
+        const url = this.getUrlByMarketType(type, isInverse);
+        const client = this.client(url);
+        this.setPositionsCache(client, type, symbols);
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        const cache = this.safeValue(this.positions, type);
+        if (fetchPositionsSnapshot && awaitPositionsSnapshot && cache === undefined) {
+            return await client.future(type + ':fetchPositionsSnapshot');
+        }
+        const positions = await this.subscribePrivate(url, messageHash, payload, channel, query, true);
+        if (this.newUpdates) {
+            return positions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+    }
+    setPositionsCache(client, type, symbols = undefined) {
+        if (this.positions === undefined) {
+            this.positions = {};
+        }
+        if (type in this.positions) {
+            return;
+        }
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', false);
+        if (fetchPositionsSnapshot) {
+            const messageHash = type + ':fetchPositionsSnapshot';
+            if (!(messageHash in client.futures)) {
+                client.future(messageHash);
+                this.spawn(this.loadPositionsSnapshot, client, messageHash, type);
+            }
+        }
+        else {
+            this.positions[type] = new Cache.ArrayCacheBySymbolBySide();
+        }
+    }
+    async loadPositionsSnapshot(client, messageHash, type) {
+        const positions = await this.fetchPositions(undefined, { 'type': type });
+        this.positions[type] = new Cache.ArrayCacheBySymbolBySide();
+        const cache = this.positions[type];
+        for (let i = 0; i < positions.length; i++) {
+            const position = positions[i];
+            cache.append(position);
+        }
+        // don't remove the future from the .futures cache
+        const future = client.futures[messageHash];
+        future.resolve(cache);
+        client.resolve(cache, type + ':position');
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        time: 1693158497,
+        //        time_ms: 1693158497204,
+        //        channel: 'futures.positions',
+        //        event: 'update',
+        //        result: [{
+        //            contract: 'XRP_USDT',
+        //            cross_leverage_limit: 0,
+        //            entry_price: 0.5253,
+        //            history_pnl: 0,
+        //            history_point: 0,
+        //            last_close_pnl: 0,
+        //            leverage: 0,
+        //            leverage_max: 50,
+        //            liq_price: 0.0361,
+        //            maintenance_rate: 0.01,
+        //            margin: 4.89609962852,
+        //            mode: 'single',
+        //            realised_pnl: -0.0026265,
+        //            realised_point: 0,
+        //            risk_limit: 500000,
+        //            size: 1,
+        //            time: 1693158497,
+        //            time_ms: 1693158497195,
+        //            update_id: 1,
+        //            user: '10444586'
+        //        }]
+        //    }
+        //
+        const type = this.getMarketTypeByUrl(client.url);
+        const data = this.safeValue(message, 'result', []);
+        const cache = this.positions[type];
+        const newPositions = [];
+        for (let i = 0; i < data.length; i++) {
+            const rawPosition = data[i];
+            const position = this.parsePosition(rawPosition);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, type + ':positions::');
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const parts = messageHash.split('::');
+            const symbolsString = parts[1];
+            const symbols = symbolsString.split(',');
+            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
+            if (!this.isEmpty(positions)) {
+                client.resolve(positions, messageHash);
+            }
+        }
+        client.resolve(newPositions, type + ':positions');
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1036,6 +1180,7 @@ class gate extends gate$1 {
             'usertrades': this.handleMyTrades,
             'candlesticks': this.handleOHLCV,
             'orders': this.handleOrder,
+            'positions': this.handlePositions,
             'tickers': this.handleTicker,
             'book_ticker': this.handleTicker,
             'trades': this.handleTrades,
@@ -1077,6 +1222,22 @@ class gate extends gate$1 {
             return url;
         }
     }
+    getMarketTypeByUrl(url) {
+        const findBy = {
+            'op-': 'option',
+            'delivery': 'future',
+            'fx': 'swap',
+        };
+        const keys = Object.keys(findBy);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const value = findBy[key];
+            if (url.indexOf(key) >= 0) {
+                return value;
+            }
+        }
+        return 'spot';
+    }
     requestId() {
         // their support said that reqid must be an int32, not documented
         const reqid = this.sum(this.safeInteger(this.options, 'reqid', 0), 1);