@mtcute/core 0.2.3 → 0.4.0

package/esm/network/session-connection.js

@@ -10,7 +10,9 @@ import { reportUnknownError } from '../utils/platform/error-reporting.js';
 import { doAuthorization } from './authorization.js';
 import { PersistentConnection } from './persistent-connection.js';
 import { TransportError } from './transports/abstract.js';
-const TEMP_AUTH_KEY_EXPIRY = 86400;
+const TEMP_AUTH_KEY_EXPIRY = 86400; // 24 hours
+const PING_INTERVAL = 60000; // 1 minute
+const GET_STATE_INTERVAL = 1500; // 1.5 seconds
 // destroy_auth_key#d1435160 = DestroyAuthKeyRes;
 // const DESTROY_AUTH_KEY = Buffer.from('605134d1', 'hex')
 // gzip_packed#3072cfa1 packed_data:string = Object;
@@ -19,6 +21,9 @@ const GZIP_PACKED_ID = 0x3072cfa1;
 const MSG_CONTAINER_ID = 0x73f1f8dc;
 // rpc_result#f35c6d01 req_msg_id:long result:Object = RpcResult;
 const RPC_RESULT_ID = 0xf35c6d01;
+// invokeAfterMsg#cb9f372d {X:Type} msg_id:long query:!X = X;
+const INVOKE_AFTER_MSG_ID = 0xcb9f372d;
+const INVOKE_AFTER_MSG_SIZE = 12; // 8 (invokeAfterMsg) + 4 (msg_id)
 function makeNiceStack(error, stack, method) {
     error.stack = `RpcError (${error.code} ${error.text}): ${error.message}\n    at ${method}\n${stack
         .split('\n')
@@ -44,6 +49,7 @@ export class SessionConnection extends PersistentConnection {
         this._readerMap = params.readerMap;
         this._writerMap = params.writerMap;
         this._crypto = params.crypto;
+        this._salts = params.salts;
         this._handleRawMessage = this._handleRawMessage.bind(this);
     }
     getAuthKey(temp = false) {
@@ -81,6 +87,7 @@ export class SessionConnection extends PersistentConnection {
     reset(forever = false) {
         this._session.initConnectionCalled = false;
         this._flushTimer.reset();
+        this._salts.isFetching = false;
         if (forever) {
             this.removeAllListeners();
         }
@@ -182,7 +189,7 @@ export class SessionConnection extends PersistentConnection {
         doAuthorization(this, this._crypto)
             .then(([authKey, serverSalt, timeOffset]) => {
             this._session._authKey.setup(authKey);
-            this._session.serverSalt = serverSalt;
+            this._salts.currentSalt = serverSalt;
             this._session._timeOffset = timeOffset;
             this._session.authorizationPending = false;
             this.emit('key-change', authKey);
@@ -300,7 +307,7 @@ export class SessionConnection extends PersistentConnection {
             // and primary is not immediately forgot because messages using it may still be in flight)
             this._session._authKeyTempSecondary = this._session._authKeyTemp;
             this._session._authKeyTemp = tempKey;
-            this._session.serverSalt = tempServerSalt;
+            this._salts.currentSalt = tempServerSalt;
             this.log.debug('temp key has been bound, exp = %d', inner.expiresAt);
             this._isPfsBindingPending = false;
             this._isPfsBindingPendingInBackground = false;
@@ -439,7 +446,7 @@ export class SessionConnection extends PersistentConnection {
                 this._onMsgsStateInfo(message);
                 break;
             case 'mt_future_salts':
-                // todo
+                this._onFutureSalts(message);
                 break;
             case 'mt_msgs_state_req':
             case 'mt_msg_resend_req':
@@ -520,7 +527,7 @@ export class SessionConnection extends PersistentConnection {
                     this.log.debug('failed to parse rpc_result for cancel request %l, ignoring', reqMsgId);
                     return;
                 }
-                this.log.debug('received %s for cancelled request %l: %j', result._, reqMsgId);
+                this.log.debug('received %s for cancelled request %l: %j', result._, reqMsgId, result);
                 this._onMessageAcked(reqMsgId);
                 return;
             }
@@ -546,6 +553,7 @@ export class SessionConnection extends PersistentConnection {
         }
         // initConnection call was definitely received and
         // processed by the server, so we no longer need to use it
+        // todo: is this the case with failed invokeAfterMsg(s) as well?
         if (rpc.initConn) {
             this._session.initConnectionCalled = true;
         }
@@ -554,37 +562,61 @@ export class SessionConnection extends PersistentConnection {
         if (result._ === 'mt_rpc_error') {
             const res = result;
             this.log.debug('received rpc_error [%d:%s] for %l (%s)', res.errorCode, res.errorMessage, reqMsgId, rpc.method);
-            if (res.errorMessage === 'AUTH_KEY_PERM_EMPTY') {
-                // happens when temp auth key is not yet bound
-                // this shouldn't happen as we block any outbound communications
-                // until the temp key is derived and bound.
-                //
-                // i think it is also possible for the error to be returned
-                // when the temp key has expired, but this still shouldn't happen
-                // but this is tg, so something may go wrong, and we will receive this as an error
-                // (for god's sake why is this not in mtproto and instead hacked into the app layer)
-                this._authorizePfs();
-                this._onMessageFailed(reqMsgId, 'AUTH_KEY_PERM_EMPTY', true);
-                return;
-            }
-            if (res.errorMessage === 'CONNECTION_NOT_INITED') {
-                // this seems to sometimes happen when using pfs
-                // no idea why, but tdlib also seems to handle these, so whatever
-                this._session.initConnectionCalled = false;
-                this._onMessageFailed(reqMsgId, res.errorMessage, true);
-                // just setting this flag is not enough because the message
-                // is already serialized, so we do this awesome hack
-                this.sendRpc({ _: 'help.getNearestDc' })
-                    .then(() => {
-                    this.log.debug('additional help.getNearestDc for initConnection ok');
-                })
-                    .catch((err) => {
-                    this.log.debug('additional help.getNearestDc for initConnection error: %s', err);
-                });
-                return;
-            }
             if (rpc.cancelled)
                 return;
+            switch (res.errorMessage) {
+                case 'AUTH_KEY_PERM_EMPTY':
+                    // happens when temp auth key is not yet bound
+                    // this shouldn't happen as we block any outbound communications
+                    // until the temp key is derived and bound.
+                    //
+                    // i think it is also possible for the error to be returned
+                    // when the temp key has expired, but this still shouldn't happen
+                    // but this is tg, so something may go wrong, and we will receive this as an error
+                    // (for god's sake why is this not in mtproto and instead hacked into the app layer)
+                    this._authorizePfs();
+                    this._onMessageFailed(reqMsgId, 'AUTH_KEY_PERM_EMPTY', true);
+                    return;
+                case 'CONNECTION_NOT_INITED': {
+                    // this seems to sometimes happen when using pfs
+                    // no idea why, but tdlib also seems to handle these, so whatever
+                    this._session.initConnectionCalled = false;
+                    this._onMessageFailed(reqMsgId, res.errorMessage, true);
+                    // just setting this flag is not enough because the message
+                    // is already serialized, so we do this awesome hack
+                    this.sendRpc({ _: 'help.getNearestDc' })
+                        .then(() => {
+                        this.log.debug('additional help.getNearestDc for initConnection ok');
+                    })
+                        .catch((err) => {
+                        this.log.debug('additional help.getNearestDc for initConnection error: %s', err);
+                    });
+                    return;
+                }
+                case 'MSG_WAIT_TIMEOUT':
+                case 'MSG_WAIT_FAILED': {
+                    if (!rpc.invokeAfter) {
+                        this.log.warn('received %s for non-chained request %l', res.errorMessage, reqMsgId);
+                        break;
+                    }
+                    // in some cases, MSG_WAIT_TIMEOUT is returned instead of MSG_WAIT_FAILED when one of the deps
+                    // failed with MSG_WAIT_TIMEOUT. i have no clue why, this makes zero sense, but what fucking ever
+                    //
+                    // this basically means we can't handle a timeout any different than a general failure,
+                    // because the timeout might not refer to the immediate `.invokeAfter` message, but to
+                    // its arbitrary-depth dependency, so we indeed have to wait for the message ourselves...
+                    if (this._session.pendingMessages.has(rpc.invokeAfter)) {
+                        // the dependency is still pending, postpone the processing
+                        this.log.debug('chain %s: waiting for %l before processing %l', rpc.chainId, rpc.invokeAfter, reqMsgId);
+                        this._session.getPendingChainedFails(rpc.chainId).insert(rpc);
+                    }
+                    else {
+                        this._session.chains.delete(rpc.chainId);
+                        this._onMessageFailed(reqMsgId, 'MSG_WAIT_FAILED', true);
+                    }
+                    return;
+                }
+            }
             const error = tl.RpcError.fromTl(res);
             if (this.params.niceStacks !== false) {
                 makeNiceStack(error, rpc.stack, rpc.method);
@@ -600,9 +632,31 @@ export class SessionConnection extends PersistentConnection {
                 return;
             rpc.promise.resolve(result);
         }
+        if (rpc.chainId) {
+            this._processPendingChainedFails(rpc.chainId, reqMsgId);
+        }
         this._onMessageAcked(reqMsgId);
         this._session.pendingMessages.delete(reqMsgId);
     }
+    _processPendingChainedFails(chainId, sinceMsgId) {
+        // sinceMsgId was already definitely received and contained an error.
+        // we should now re-send all the pending MSG_WAIT_FAILED after it
+        this._session.removeFromChain(chainId, sinceMsgId);
+        const oldPending = this._session.chainsPendingFails.get(chainId);
+        if (!oldPending?.length) {
+            return;
+        }
+        const idx = oldPending.index({ invokeAfter: sinceMsgId }, true);
+        if (idx === -1)
+            return;
+        const toFail = oldPending.raw.splice(idx);
+        this.log.debug('chain %s: failing %d dependant messages: %L', chainId, toFail.length, toFail);
+        // we're failing the rest of the chain, including the last message
+        this._session.chains.delete(chainId);
+        for (const rpc of toFail) {
+            this._onMessageFailed(rpc.msgId, 'MSG_WAIT_FAILED', true);
+        }
+    }
     _onMessageAcked(msgId, inContainer = false) {
         const msg = this._session.pendingMessages.get(msgId);
         if (!msg) {
@@ -634,6 +688,7 @@ export class SessionConnection extends PersistentConnection {
                 break;
             }
             case 'bind':
+            case 'cancel':
                 break; // do nothing, wait for the result
             default:
                 if (!inContainer) {
@@ -708,6 +763,12 @@ export class SessionConnection extends PersistentConnection {
             case 'bind':
                 this.log.debug('temp key binding request %l failed because of %s, retrying', msgId, reason);
                 msgInfo.promise.reject(Error(reason));
+                break;
+            case 'future_salts':
+                this.log.debug('future_salts request %l failed because of %s, will retry', msgId, reason);
+                this._salts.isFetching = false;
+                // this is enough to make it retry on the next flush.
+                break;
         }
         this._session.pendingMessages.delete(msgId);
     }
@@ -737,7 +798,7 @@ export class SessionConnection extends PersistentConnection {
         this._session.resetLastPing();
     }
     _onBadServerSalt(msg) {
-        this._session.serverSalt = msg.newServerSalt;
+        this._salts.currentSalt = msg.newServerSalt;
         this._onMessageFailed(msg.badMsgId, 'bad_server_salt');
     }
     _onBadMsgNotification(msgId, msg) {
@@ -775,7 +836,7 @@ export class SessionConnection extends PersistentConnection {
             // just been established, and the client will fetch them anyways
             this.emit('update', { _: 'updatesTooLong' });
         }
-        this._session.serverSalt = serverSalt;
+        this._salts.currentSalt = serverSalt;
         this.log.debug('received new_session_created, uid = %l, first msg_id = %l', uniqueId, firstMsgId);
         for (const msgId of this._session.pendingMessages.keys()) {
             const val = this._session.pendingMessages.get(msgId);
@@ -814,7 +875,7 @@ export class SessionConnection extends PersistentConnection {
                 case 2:
                 case 3:
                     // message wasn't received by the server
-                    this._onMessageFailed(msgId, `message info state ${status}`);
+                    return this._onMessageFailed(msgId, `message info state ${status}`);
                     break;
                 case 0:
                     if (!answerMsgId.isZero()) {
@@ -833,6 +894,10 @@ export class SessionConnection extends PersistentConnection {
             this._flushTimer.emitWhenIdle();
             return;
         }
+        if (answerMsgId.isZero()) {
+            this.log.debug('received message info for %l: message is still pending (status = %d)', msgId, status);
+            return;
+        }
         this.log.debug('received message info for %l, and answer (%l) was already received', msgId, answerMsgId);
     }
     _onMessagesInfo(msgIds, info) {
@@ -855,6 +920,21 @@ export class SessionConnection extends PersistentConnection {
         }
         this._onMessagesInfo(info.msgIds, msg.info);
     }
+    _onFutureSalts(msg) {
+        const info = this._session.pendingMessages.get(msg.reqMsgId);
+        if (!info) {
+            this.log.warn('received future_salts to unknown request %l', msg.reqMsgId);
+            return;
+        }
+        if (info._ !== 'future_salts') {
+            this.log.warn('received future_salts to %s query %l', info._, msg.reqMsgId);
+            return;
+        }
+        this.log.debug('received future_salts: %d salts', msg.salts.length);
+        this._salts.isFetching = false;
+        this._salts.setFutureSalts(msg.salts.slice());
+        this.emit('future-salts', msg.salts);
+    }
     _onDestroySessionResult(msg) {
         const reqMsgId = this._session.destroySessionIdToMsgId.get(msg.sessionId);
         if (!reqMsgId) {
@@ -886,7 +966,7 @@ export class SessionConnection extends PersistentConnection {
             this._flushTimer.emitWhenIdle();
         }
     }
-    sendRpc(request, stack, timeout, abortSignal) {
+    sendRpc(request, stack, timeout, abortSignal, chainId) {
         if (this._usable && this.params.inactivityTimeout) {
             this._rescheduleInactivity();
         }
@@ -957,7 +1037,9 @@ export class SessionConnection extends PersistentConnection {
             // we will need to know size of gzip_packed overhead in _flush()
             gzipOverhead: shouldGzip ? 4 + TlSerializationCounter.countBytesOverhead(content.length) : 0,
             initConn,
+            chainId,
             // setting them as well so jit can optimize stuff
+            invokeAfter: undefined,
             sent: undefined,
             done: undefined,
             getState: undefined,
@@ -1004,6 +1086,7 @@ export class SessionConnection extends PersistentConnection {
         rpc.cancelled = true;
         if (rpc.msgId) {
             this._session.queuedCancelReq.push(rpc.msgId);
+            this._session.getStateSchedule.remove(rpc);
             this._flushTimer.emitWhenIdle();
         }
         else {
@@ -1015,6 +1098,20 @@ export class SessionConnection extends PersistentConnection {
     _onInactivityTimeout() {
         // we should send all pending acks and other service messages
         // before dropping the connection
+        // additionally, if we are still waiting for some rpc results,
+        // we should wait for them first
+        let hasPendingRpc = false;
+        for (const it of this._session.pendingMessages.values()) {
+            if (it._ === 'rpc') {
+                hasPendingRpc = true;
+                break;
+            }
+        }
+        if (hasPendingRpc) {
+            this.log.debug('waiting for pending rpc queries to finish before closing connection');
+            this._rescheduleInactivity();
+            return;
+        }
         if (!this._session.hasPendingMessages) {
             this.log.debug('no pending service messages, closing connection');
             super._onInactivityTimeout();
@@ -1047,14 +1144,10 @@ export class SessionConnection extends PersistentConnection {
             // between multiple connections using the same session
             this._flushTimer.emitWhenIdle();
         }
-        else if (this._inactivityPendingFlush) {
-            this.log.debug('pending messages sent, closing connection');
-            this._flushTimer.reset();
-            this._inactivityPendingFlush = false;
-            super._onInactivityTimeout();
-        }
         else {
-            this._flushTimer.emitBefore(this._session.lastPingTime + 60000);
+            const nextPingTime = this._session.lastPingTime + PING_INTERVAL;
+            const nextGetScheduleTime = this._session.getStateSchedule.raw[0]?.getState || Infinity;
+            this._flushTimer.emitBefore(Math.min(nextPingTime, nextGetScheduleTime));
         }
     }
     _doFlush() {
@@ -1069,6 +1162,8 @@ export class SessionConnection extends PersistentConnection {
         let containerSize = 0;
         let ackRequest = null;
         let ackMsgIds = null;
+        let getFutureSaltsRequest = null;
+        let getFutureSaltsMsgId = null;
         let pingRequest = null;
         let pingId = null;
         let pingMsgId = null;
@@ -1100,16 +1195,16 @@ export class SessionConnection extends PersistentConnection {
             packetSize += ackRequest.length + 16;
             messageCount += 1;
         }
-        const getStateTime = now + 1500;
-        if (now - this._session.lastPingTime > 60000) {
+        if (now - this._session.lastPingTime > PING_INTERVAL) {
             if (!this._session.lastPingMsgId.isZero()) {
                 this.log.warn("didn't receive pong for previous ping (msg_id = %l)", this._session.lastPingMsgId);
                 this._session.pendingMessages.delete(this._session.lastPingMsgId);
             }
             pingId = randomLong();
             const obj = {
-                _: 'mt_ping',
+                _: 'mt_ping_delay_disconnect',
                 pingId,
+                disconnectDelay: 75,
             };
             this._session.lastPingTime = Date.now();
             pingRequest = TlBinaryWriter.serializeObject(this._writerMap, obj);
@@ -1174,6 +1269,16 @@ export class SessionConnection extends PersistentConnection {
             destroySessions = this._queuedDestroySession;
             this._queuedDestroySession = [];
         }
+        if (this._salts.shouldFetchSalts()) {
+            const obj = {
+                _: 'mt_get_future_salts',
+                num: 64,
+            };
+            getFutureSaltsRequest = TlBinaryWriter.serializeObject(this._writerMap, obj);
+            containerSize += getFutureSaltsRequest.length + 16;
+            containerMessageCount += 1;
+            this._salts.isFetching = true;
+        }
         let forceContainer = false;
         const rpcToSend = [];
         while (this._session.queuedRpc.length &&
@@ -1189,6 +1294,9 @@ export class SessionConnection extends PersistentConnection {
             containerSize += msg.data.length + 16;
             if (msg.gzipOverhead)
                 containerSize += msg.gzipOverhead;
+            if (msg.chainId) {
+                containerSize += INVOKE_AFTER_MSG_SIZE;
+            }
             // if message was already assigned a msg_id,
             // we must wrap it in a container with a newer msg_id
             if (msg.msgId)
@@ -1281,6 +1389,16 @@ export class SessionConnection extends PersistentConnection {
                 otherPendings.push(pending);
             });
         }
+        if (getFutureSaltsRequest) {
+            getFutureSaltsMsgId = this._registerOutgoingMsgId(this._session.writeMessage(writer, getFutureSaltsRequest));
+            const pending = {
+                _: 'future_salts',
+                containerId: getFutureSaltsMsgId,
+            };
+            this._session.pendingMessages.set(getFutureSaltsMsgId, pending);
+            otherPendings.push(pending);
+        }
+        const getStateTime = now + GET_STATE_INTERVAL;
         for (let i = 0; i < rpcToSend.length; i++) {
             const msg = rpcToSend[i];
             // not using writeMessage here because we also need seqNo, and
@@ -1296,6 +1414,10 @@ export class SessionConnection extends PersistentConnection {
                     _: 'rpc',
                     rpc: msg,
                 });
+                if (msg.chainId) {
+                    msg.invokeAfter = this._session.addToChain(msg.chainId, msgId);
+                    this.log.debug('chain %s: invoke %l after %l', msg.chainId, msg.msgId, msg.invokeAfter);
+                }
             }
             else {
                 this.log.debug('%s: msg_id already assigned, reusing %l, seqno: %d', msg.method, msg.msgId, msg.seqNo);
@@ -1312,13 +1434,22 @@ export class SessionConnection extends PersistentConnection {
                 rootMsgId = msg.msgId;
             writer.long(this._registerOutgoingMsgId(msg.msgId));
             writer.uint(msg.seqNo);
+            const invokeAfterSize = msg.invokeAfter ? INVOKE_AFTER_MSG_SIZE : 0;
+            const writeInvokeAfter = () => {
+                if (!msg.invokeAfter)
+                    return;
+                writer.uint(INVOKE_AFTER_MSG_ID);
+                writer.long(msg.invokeAfter);
+            };
             if (msg.gzipOverhead) {
-                writer.uint(msg.data.length + msg.gzipOverhead);
-                writer.uint(0x3072cfa1); // gzip_packed#3072cfa1
+                writer.uint(msg.data.length + msg.gzipOverhead + invokeAfterSize);
+                writeInvokeAfter();
+                writer.uint(GZIP_PACKED_ID);
                 writer.bytes(msg.data);
             }
             else {
-                writer.uint(msg.data.length);
+                writer.uint(msg.data.length + invokeAfterSize);
+                writeInvokeAfter();
                 writer.raw(msg.data);
             }
             msg.sent = true;
@@ -1327,7 +1458,7 @@ export class SessionConnection extends PersistentConnection {
             // we now need to assign the container msg_id and seqno
             // we couldn't have assigned them earlier because mtproto
             // requires them to be >= than the contained messages
-            // writer.pos is expected to be packetSize
+            packetSize = writer.pos;
             const containerId = this._session.getMessageId();
             writer.pos = 0;
             rootMsgId = containerId;
@@ -1353,9 +1484,9 @@ export class SessionConnection extends PersistentConnection {
             });
         }
         const result = writer.result();
-        this.log.debug('sending %d messages: size = %db, acks = %d (msg_id = %s), ping = %s (msg_id = %s), state_req = %s (msg_id = %s), resend = %s (msg_id = %s), cancels = %s (msg_id = %s), rpc = %s, container = %s, root msg_id = %l', messageCount, packetSize, ackMsgIds?.length || 'false', ackMsgIds?.map((it) => it.toString()), Boolean(pingRequest), pingMsgId, getStateMsgIds?.map((it) => it.toString()) || 'false', getStateMsgId, resendMsgIds?.map((it) => it.toString()) || 'false', cancelRpcs, cancelRpcs?.map((it) => it.toString()) || 'false', resendMsgId, rpcToSend.map((it) => it.method), useContainer, rootMsgId);
+        this.log.debug('sending %d messages: size = %db, acks = %L, ping = %b (msg_id = %l), state_req = %L (msg_id = %l), resend = %L (msg_id = %l), cancels = %L (msg_id = %l), salts_req = %b (msg_id = %l), rpc = %s, container = %b, root msg_id = %l', messageCount, packetSize, ackMsgIds, pingRequest, pingMsgId, getStateMsgIds, getStateMsgId, resendMsgIds, cancelRpcs, cancelRpcs, resendMsgId, getFutureSaltsRequest, getFutureSaltsMsgId, rpcToSend.map((it) => it.method), useContainer, rootMsgId);
         const enc = this._session.encryptMessage(result);
-        this.send(enc).catch((err) => {
+        const promise = this.send(enc).catch((err) => {
             this.log.error('error while sending pending messages (root msg_id = %l): %s', rootMsgId, err.stack);
             // put acks in the front so they are the first to be sent
             if (ackMsgIds) {
@@ -1365,6 +1496,14 @@ export class SessionConnection extends PersistentConnection {
                 this._onMessageFailed(rootMsgId, 'unknown error');
             }
         });
+        if (this._inactivityPendingFlush && !this._session.hasPendingMessages) {
+            void promise.then(() => {
+                this.log.debug('pending messages sent, closing connection');
+                this._flushTimer.reset();
+                this._inactivityPendingFlush = false;
+                super._onInactivityTimeout();
+            });
+        }
     }
 }
 //# sourceMappingURL=session-connection.js.map