nodejs-insta-private-api-mqt 1.3.83 → 1.3.84

package/dist-ts/dist/repositories/account.repository.js

@@ -0,0 +1,1267 @@
+const Repository = require('../core/repository');
+const crypto = require('crypto');
+class AccountRepository extends Repository {
+    constructor(client) {
+        super(client);
+        this.maxRetries = 3;
+    }
+    async requestWithRetry(requestFn, retries = 0) {
+        var _a, _b;
+        try {
+            const result = await requestFn();
+            return result;
+        }
+        catch (error) {
+            const shouldRetry = (((_a = error.data) === null || _a === void 0 ? void 0 : _a.error_type) === 'server_error' ||
+                ((_b = error.data) === null || _b === void 0 ? void 0 : _b.error_type) === 'rate_limited') &&
+                retries < this.maxRetries;
+            if (shouldRetry) {
+                const delay = 1000 * (retries + 1);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                return this.requestWithRetry(requestFn, retries + 1);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Helper: try to extract an IGT bearer token from various sources:
+     * - response.headers (IG-Set-Authorization or ig-set-authorization)
+     * - response.body top-level fields
+     * - body.layout (stringified layout)
+     * - any embedded login_response.headers JSON inside layout or body
+     *
+     * When found, sets this.client.state.authorization and calls updateAuthorization().
+     */
+    _extractAndSaveAuthorization(response) {
+        var _a;
+        if (!response)
+            return null;
+        // Normalize headers (case-insensitive)
+        const headers = {};
+        if (response.headers && typeof response.headers === 'object') {
+            for (const k of Object.keys(response.headers)) {
+                headers[k.toLowerCase()] = response.headers[k];
+            }
+        }
+        // Simpler: look for any header that contains ig-set-authorization
+        for (const key of Object.keys(headers)) {
+            const val = headers[key];
+            if (!val)
+                continue;
+            if (key.includes('ig-set-authorization')) {
+                const token = this._normalizeTokenString(val);
+                if (token) {
+                    this.client.state.authorization = token;
+                    try {
+                        this.client.state.updateAuthorization();
+                    }
+                    catch (e) { }
+                    return token;
+                }
+            }
+            // Some servers include the header value inside a JSON-like string in other headers
+            if (typeof val === 'string' && val.includes('Bearer IGT:2:')) {
+                const token = this._findBearerInString(val);
+                if (token) {
+                    this.client.state.authorization = token;
+                    try {
+                        this.client.state.updateAuthorization();
+                    }
+                    catch (e) { }
+                    return token;
+                }
+            }
+        }
+        // Extract IG-U headers (user id, region, claim) when present
+        const dsUserIdHeader = headers['ig-set-ig-u-ds-user-id'] ||
+            headers['ig-u-ds-user-id'] ||
+            headers['x-ig-set-ig-u-ds-user-id'];
+        if (dsUserIdHeader) {
+            const m = String(dsUserIdHeader).match(/(\d{3,})/);
+            if (m) {
+                const uid = m[1];
+                this.client.state.cookieUserId = uid;
+                this.client.state._userId = uid;
+            }
+        }
+        const rurHeader = headers['ig-set-ig-u-rur'] ||
+            headers['ig-u-rur'] ||
+            headers['x-ig-set-ig-u-rur'];
+        if (rurHeader) {
+            const rur = String(rurHeader).trim().replace(/^"|"$/g, '');
+            if (rur) {
+                this.client.state.igURur = rur;
+            }
+        }
+        const wwwClaimHeader = headers['x-ig-set-www-claim'] ||
+            headers['ig-set-www-claim'] ||
+            headers['ig-u-www-claim'];
+        if (wwwClaimHeader) {
+            const claim = String(wwwClaimHeader).trim().replace(/^"|"$/g, '');
+            if (claim) {
+                this.client.state.igWWWClaim = claim;
+            }
+        }
+        const midHeader = headers['ig-set-x-mid'] ||
+            headers['x-mid'] ||
+            headers['ig-set-mid'];
+        if (midHeader) {
+            const mid = String(midHeader).trim().replace(/^"|"$/g, '');
+            if (mid) {
+                this.client.state.mid = mid;
+            }
+        }
+        // 2) Check response.body for common fields
+        const body = response.body;
+        if (body) {
+            // If body has headers string (some responses embed headers JSON as a string)
+            if (body.headers && typeof body.headers === 'string') {
+                const token = this._findBearerInString(body.headers);
+                if (token) {
+                    this.client.state.authorization = token;
+                    try {
+                        this.client.state.updateAuthorization();
+                    }
+                    catch (e) { }
+                    return token;
+                }
+            }
+            // If body contains a layout object or string, stringify and search it
+            try {
+                let layoutStr = null;
+                if (body.layout) {
+                    layoutStr = typeof body.layout === 'string' ? body.layout : JSON.stringify(body.layout);
+                }
+                else if ((_a = body === null || body === void 0 ? void 0 : body.layout) === null || _a === void 0 ? void 0 : _a.bloks_payload) {
+                    layoutStr = JSON.stringify(body.layout.bloks_payload);
+                }
+                else if (body === null || body === void 0 ? void 0 : body.bloks_payload) {
+                    layoutStr = JSON.stringify(body.bloks_payload);
+                }
+                if (!layoutStr && typeof body === 'string') {
+                    layoutStr = body;
+                }
+                if (layoutStr) {
+                    const token = this._findBearerInString(layoutStr);
+                    if (token) {
+                        this.client.state.authorization = token;
+                        try {
+                            this.client.state.updateAuthorization();
+                        }
+                        catch (e) { }
+                        return token;
+                    }
+                    // Some responses embed a login_response JSON string inside layout; try to extract it
+                    const loginResponseMatch = layoutStr.match(/"login_response"\s*:\s*"(\\?{.*?\\?})"/s);
+                    if (loginResponseMatch) {
+                        // Unescape JSON string
+                        let jsonStr = loginResponseMatch[1];
+                        try {
+                            jsonStr = jsonStr.replace(/\\"/g, '"').replace(/\\n/g, '');
+                            const parsed = JSON.parse(jsonStr);
+                            if (parsed && parsed.headers) {
+                                const token = this._findBearerInString(parsed.headers);
+                                if (token) {
+                                    this.client.state.authorization = token;
+                                    try {
+                                        this.client.state.updateAuthorization();
+                                    }
+                                    catch (e) { }
+                                    return token;
+                                }
+                            }
+                        }
+                        catch (e) {
+                            // ignore parse errors
+                        }
+                    }
+                    // Also try to find IG-Set-Password-Encryption headers (not token but useful)
+                    const encKeyIdMatch = layoutStr.match(/IG-Set-Password-Encryption-Key-Id[\\"\s:]+(\d+)/i) ||
+                        layoutStr.match(/password.encryption.key.id[\\"\s:]+(\d+)/i);
+                    if (encKeyIdMatch) {
+                        this.client.state.passwordEncryptionKeyId = parseInt(encKeyIdMatch[1]);
+                    }
+                    const encPubKeyMatch = layoutStr.match(/IG-Set-Password-Encryption-Pub-Key[\\"\s:]+([A-Za-z0-9+\/=]+)/i) ||
+                        layoutStr.match(/password.encryption.pub.key[\\"\s:]+([A-Za-z0-9+\/=]+)/i);
+                    if (encPubKeyMatch) {
+                        this.client.state.passwordEncryptionPubKey = encPubKeyMatch[1];
+                    }
+                    // Extract user/account identifiers from layout string
+                    const dsIdMatch = layoutStr.match(/ig-set-ig-u-ds-user-id[\\"\s:]+(\d+)/i) ||
+                        layoutStr.match(/ig-u-ds-user-id[\\"\s:]+(\d+)/i) ||
+                        layoutStr.match(/"strong_id__"\s*:\s*"(\d+)"/i) ||
+                        layoutStr.match(/"pk_id"\s*:\s*"(\d+)"/i) ||
+                        layoutStr.match(/"pk"\s*:\s*(\d+)/i);
+                    if (dsIdMatch) {
+                        const uid = String(dsIdMatch[1]);
+                        this.client.state.cookieUserId = uid;
+                        this.client.state._userId = uid;
+                    }
+                    const rurMatch = layoutStr.match(/ig-set-ig-u-rur[\\"\s:]+"([^"\\]+)/i) ||
+                        layoutStr.match(/ig-u-rur[\\"\s:]+"([^"\\]+)/i);
+                    if (rurMatch) {
+                        this.client.state.igURur = rurMatch[1];
+                    }
+                    const wwwClaimMatch = layoutStr.match(/x-ig-set-www-claim[\\"\s:]+"([^"\\]+)/i);
+                    if (wwwClaimMatch) {
+                        this.client.state.igWWWClaim = wwwClaimMatch[1];
+                    }
+                    const midMatch = layoutStr.match(/"mid"\s*:\s*"([^"\\]+)"/i);
+                    if (midMatch) {
+                        this.client.state.mid = midMatch[1];
+                    }
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+            // 3) If body.logged_in_user exists and we have authorization already, return it
+            if (body.logged_in_user && this.client.state.authorization) {
+                return this.client.state.authorization;
+            }
+        }
+        return null;
+    }
+    // Normalize token string: accept either raw token or "Bearer IGT:2:..." and return trimmed token string
+    _normalizeTokenString(val) {
+        if (!val || typeof val !== 'string')
+            return null;
+        // If header already contains "Bearer IGT:2:..."
+        const bearer = this._findBearerInString(val);
+        if (bearer)
+            return bearer;
+        // If header contains JSON with IG-Set-Authorization field
+        try {
+            const maybeJson = JSON.parse(val);
+            if (maybeJson['IG-Set-Authorization']) {
+                return this._findBearerInString(maybeJson['IG-Set-Authorization']);
+            }
+        }
+        catch (e) {
+            // not JSON
+        }
+        // fallback: return trimmed value
+        return val.trim();
+    }
+    // Find bearer token in arbitrary string using multiple patterns
+    _findBearerInString(str) {
+        if (!str || typeof str !== 'string')
+            return null;
+        // Patterns to match the Bearer token in many possible encodings/escapes
+        const bearerPatterns = [
+            /Bearer IGT:2:[A-Za-z0-9+\/=]+/,
+            /Bearer\s+IGT:2:[A-Za-z0-9+\/=]+/,
+            /\?"Bearer IGT:2:([A-Za-z0-9+\/=]+)\?"/,
+            /ig-set-authorization[\\"\s:]*Bearer IGT:2:([A-Za-z0-9+\/=]+)/i,
+            /"IG-Set-Authorization"\s*:\s*"(Bearer IGT:2:[A-Za-z0-9+\/=]+)"/i,
+            /IG-Set-Authorization[\s:]+(Bearer IGT:2:[A-Za-z0-9+\/=]+)/i,
+            /Bearer IGT:2:([A-Za-z0-9+\/=]+)/,
+        ];
+        for (const pattern of bearerPatterns) {
+            const m = str.match(pattern);
+            if (m) {
+                // If capturing group present, prefer it
+                if (m[1]) {
+                    const token = m[1].includes('Bearer IGT:2:') ? m[1] : `Bearer IGT:2:${m[1]}`;
+                    return token.replace(/\?"/g, '').trim();
+                }
+                // Otherwise m[0] contains the full token
+                return m[0].replace(/\?"/g, '').trim();
+            }
+        }
+        return null;
+    }
+    // Ensure we have a valid csrftoken cookie (and mid) before sensitive endpoints.
+    // Instagram typically sets csrftoken via /api/v1/si/fetch_headers/.
+    async ensureCsrfToken() {
+        const cookieToken = this.client.state.cookieCsrfToken;
+        if (cookieToken && cookieToken !== 'missing' && cookieToken !== 'pending') {
+            try {
+                this.client.state.csrfToken = cookieToken;
+            }
+            catch { }
+            return cookieToken;
+        }
+        // Warmup endpoint that returns/set cookies (csrftoken, mid, etc.)
+        try {
+            await this.client.request.send({
+                method: 'GET',
+                url: `/api/v1/si/fetch_headers/?challenge_type=signup&guid=${this.client.state.uuid}`,
+            });
+        }
+        catch (e) {
+            // ignore warmup failures
+        }
+        const token = this.client.state.cookieCsrfToken;
+        if (token && token !== 'missing' && token !== 'pending') {
+            try {
+                this.client.state.csrfToken = token;
+            }
+            catch { }
+            return token;
+        }
+        return null;
+    }
+    async login(credentialsOrUsername, passwordArg) {
+        let username, password;
+        if (typeof credentialsOrUsername === 'object' && credentialsOrUsername !== null) {
+            username = credentialsOrUsername.username;
+            password = credentialsOrUsername.password;
+        }
+        else {
+            username = credentialsOrUsername;
+            password = passwordArg;
+        }
+        if (!username || !password) {
+            throw new Error('Username and password are required');
+        }
+        if (!this.client.state.passwordEncryptionPubKey) {
+            await this.syncLoginExperiments();
+        }
+        const { encrypted, time } = this.encryptPassword(password);
+        // optional CSRF warmup (like app does before login)
+        await this.ensureCsrfToken();
+        return this.requestWithRetry(async () => {
+            // ====== client_input_params (oglindă după traficul real) ======
+            const nowSec = Math.floor(Date.now() / 1000);
+            const aacInitTimestamp = nowSec - Math.floor(Math.random() * 50);
+            const aacjid = crypto.randomUUID ? crypto.randomUUID() : require('uuid').v4();
+            const aaccs = crypto.randomBytes(32).toString('base64').replace(/=/g, '');
+            const androidDeviceId = this.client.state.androidDeviceId ||
+                this.client.state.deviceId ||
+                `android-${crypto.randomBytes(8).toString('hex')}`;
+            const machineId = this.client.state.mid ||
+                this.client.state.machineId ||
+                `aZ${crypto.randomBytes(8).toString('hex')}`;
+            const familyDeviceId = this.client.state.phoneId ||
+                this.client.state.familyDeviceId ||
+                crypto.randomUUID
+                ? crypto.randomUUID()
+                : require('uuid').v4();
+            const qeDeviceId = this.client.state.deviceId ||
+                this.client.state.qeDeviceId ||
+                crypto.randomUUID
+                ? crypto.randomUUID()
+                : require('uuid').v4();
+            const accountsList = this.client.state.accountsList || [];
+            const flashCallPermissionStatus = {
+                READ_PHONE_STATE: 'GRANTED',
+                READ_CALL_LOG: 'GRANTED',
+                ANSWER_PHONE_CALLS: 'GRANTED',
+            };
+            const clientInputParams = {
+                aac: JSON.stringify({
+                    aac_init_timestamp: aacInitTimestamp,
+                    aacjid,
+                    aaccs,
+                }),
+                sim_phones: [],
+                aymh_accounts: [],
+                network_bssid: null,
+                secure_family_device_id: '',
+                has_granted_read_contacts_permissions: 0,
+                auth_secure_device_id: '',
+                has_whatsapp_installed: 1,
+                password: `#PWD_INSTAGRAM:4:${time}:${encrypted}`,
+                sso_token_map_json_string: JSON.stringify({
+                    [this.client.state.cookieUserId || '0']: [],
+                }),
+                block_store_machine_id: '',
+                ig_vetted_device_nonces: JSON.stringify({}),
+                cloud_trust_token: null,
+                event_flow: 'login_manual',
+                password_contains_non_ascii: 'false',
+                client_known_key_hash: '',
+                encrypted_msisdn: '',
+                has_granted_read_phone_permissions: 0,
+                app_manager_id: '',
+                should_show_nested_nta_from_aymh: 0,
+                device_id: androidDeviceId,
+                zero_balance_state: '',
+                login_attempt_count: 1,
+                machine_id: machineId,
+                flash_call_permission_status: flashCallPermissionStatus,
+                accounts_list: accountsList,
+                gms_incoming_call_retriever_eligibility: 'client_not_supported',
+                family_device_id: familyDeviceId,
+                fb_ig_device_id: [],
+                device_emails: [],
+                try_num: 1,
+                lois_settings: { lois_token: '' },
+                event_step: 'home_page',
+                headers_infra_flow_id: '',
+                openid_tokens: {},
+                contact_point: username,
+            };
+            // ====== server_params (oglindă după traficul real) ======
+            const waterfallId = crypto.randomUUID ? crypto.randomUUID() : require('uuid').v4();
+            const latencyMarkerId = 36707139;
+            const latencyInstanceId = Number(`${Date.now()}${Math.floor(Math.random() * 1000)}`);
+            const serverParams = {
+                should_trigger_override_login_2fa_action: 0,
+                is_vanilla_password_page_empty_password: 0,
+                is_from_logged_out: 0,
+                should_trigger_override_login_success_action: 0,
+                login_credential_type: 'none',
+                server_login_source: 'login',
+                waterfall_id: waterfallId,
+                two_step_login_type: 'one_step_login',
+                login_source: 'Login',
+                is_platform_login: 0,
+                INTERNAL__latency_qpl_marker_id: latencyMarkerId,
+                is_from_aymh: 0,
+                offline_experiment_group: 'caa_iteration_v3_perf_ig_4',
+                is_from_landing_page: 0,
+                left_nav_button_action: 'NONE',
+                password_text_input_id: 'z0jejq:194',
+                is_from_empty_password: 0,
+                is_from_msplit_fallback: 0,
+                ar_event_source: 'login_home_page',
+                qe_device_id: qeDeviceId,
+                username_text_input_id: 'z0jejq:193',
+                layered_homepage_experiment_group: null,
+                device_id: androidDeviceId,
+                login_surface: 'switcher',
+                INTERNAL__latency_qpl_instance_id: latencyInstanceId,
+                reg_flow_source: 'login_home_native_integration_point',
+                is_caa_perf_enabled: 1,
+                credential_type: 'password',
+                is_from_password_entry_page: 0,
+                caller: 'gslr',
+                family_device_id: familyDeviceId,
+                is_from_assistive_id: 0,
+                access_flow_version: 'pre_mt_behavior',
+                is_from_logged_in_switcher: 1,
+            };
+            const paramsJson = JSON.stringify({
+                client_input_params: clientInputParams,
+                server_params: serverParams,
+            });
+            const attestParams = AccountRepository.generateAttestParams(this.client.state);
+            const bkClientContext = JSON.stringify({
+                bloks_version: this.client.state.bloksVersionId,
+                styles_id: 'instagram',
+            });
+            // ====== HEADERS – modelate după request_i.instagram.com_mlwzj8x1.txt ======
+            const lang = (this.client.state.language || 'ro_RO');
+            const acceptLanguage = `${lang.replace('_', '-')}, en-US`;
+            const userAgent = this.client.state.userAgent ||
+                'Instagram 371.0.0.0.23 Android (30/11; 320dpi; 720x1449; Xiaomi/Redmi; M2006C3MNG; angelican; mt6765; ro_RO; 703217507)';
+            const bloksHeaders = {
+                'accept-language': acceptLanguage,
+                'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+                'ig-intended-user-id': '0',
+                'priority': 'u=3',
+                'x-bloks-is-layout-rtl': 'false',
+                'x-bloks-prism-ax-base-colors-enabled': 'false',
+                'x-bloks-prism-button-version': 'CONTROL',
+                'x-bloks-prism-colors-enabled': 'true',
+                'x-bloks-prism-font-enabled': 'false',
+                'x-bloks-prism-indigo-link-version': '0',
+                'x-bloks-version-id': this.client.state.bloksVersionId,
+                'x-fb-client-ip': 'True',
+                'x-fb-connection-type': 'WIFI',
+                'x-fb-friendly-name': 'IgApi: bloks/async_action/com.bloks.www.bloks.caa.login.async.send_login_request/',
+                'x-fb-network-properties': 'VPN;Validated;LocalAddrs=/10.0.0.2,;',
+                'x-fb-request-analytics-tags': JSON.stringify({
+                    network_tags: {
+                        product: String(this.client.state.fbAnalyticsApplicationId || '567067343352427'),
+                        purpose: 'fetch',
+                        surface: 'undefined',
+                        request_category: 'api',
+                        retry_attempt: '0',
+                    },
+                }),
+                'x-fb-server-cluster': 'True',
+                'x-ig-android-id': androidDeviceId,
+                'x-ig-app-id': String(this.client.state.fbAnalyticsApplicationId || '567067343352427'),
+                'x-ig-app-locale': lang,
+                'x-ig-attest-params': JSON.stringify(attestParams),
+                'x-ig-bandwidth-speed-kbps': (Math.random() * 1500 + 800).toFixed(3),
+                'x-ig-bandwidth-totalbytes-b': '0',
+                'x-ig-bandwidth-totaltime-ms': '0',
+                'x-ig-client-endpoint': 'com.bloks.www.caa.login.aymh_single_profile_screen_entry',
+                'x-ig-capabilities': '3brTv10=',
+                'x-ig-connection-type': 'WIFI',
+                'x-ig-device-id': qeDeviceId,
+                'x-ig-device-locale': lang,
+                'x-ig-family-device-id': familyDeviceId,
+                'x-ig-mapped-locale': lang,
+                'x-ig-nav-chain': 'LockoutFragment:dogfooding_lockout:1:cold_start:...,' +
+                    'com.bloks.www.caa.login.aymh_single_profile_screen_entry:com.bloks.www.caa.login.aymh_single_profile_screen_entry:14:button:0:::0',
+                'x-ig-timezone-offset': String(typeof this.client.state.timezoneOffset === 'number'
+                    ? this.client.state.timezoneOffset
+                    : 7200),
+                'x-ig-www-claim': this.client.state.igWWWClaim || '0',
+                'x-mid': machineId,
+                'x-pigeon-rawclienttime': `${nowSec}.${Math.floor(Math.random() * 1000)
+                    .toString()
+                    .padStart(3, '0')}`,
+                'x-pigeon-session-id': this.client.state.pigeonSessionId ||
+                    `UFS-${crypto.randomBytes(16).toString('hex')}-1`,
+                'x-tigon-is-retry': 'False',
+                // ...
+                'accept-encoding': 'gzip, deflate, br',
+                // ...
+                'user-agent': userAgent,
+                'x-fb-conn-uuid-client': crypto.randomBytes(16).toString('hex'),
+                'x-fb-http-engine': 'MNS/TCP',
+                'x-fb-rmd': 'state=URL_ELIGIBLE',
+            };
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/bloks/async_action/com.bloks.www.bloks.caa.login.async.send_login_request/',
+                form: {
+                    params: paramsJson,
+                    bk_client_context: bkClientContext,
+                    bloks_versioning_id: this.client.state.bloksVersionId,
+                },
+                headers: bloksHeaders,
+            });
+            // === DEBUG LOGIN: salvăm răspunsul pentru analiză ===
+            try {
+                const fs = require('fs');
+                const path = require('path');
+                const debugDir = path.join(process.cwd(), 'authinfo_instagram');
+                const debugFile = path.join(debugDir, 'login-debug.json');
+                try {
+                    fs.mkdirSync(debugDir, { recursive: true });
+                }
+                catch (e) { }
+                const debugPayload = {
+                    at: new Date().toISOString(),
+                    statusCode: response.statusCode || response.status || null,
+                    headers: response.headers || null,
+                    body: response.body || null,
+                };
+                fs.writeFileSync(debugFile, JSON.stringify(debugPayload, null, 2), 'utf8');
+            }
+            catch (e) {
+                // nu stricăm login-ul dacă nu merge debug-ul
+            }
+            // === SFÂRȘIT DEBUG LOGIN ===
+            const body = response.body;
+            // Immediately attempt to extract and save authorization token from the response
+            this._extractAndSaveAuthorization(response);
+            if (body && body.two_factor_required) {
+                const err = new Error('Two factor authentication required');
+                err.name = 'IgLoginTwoFactorRequiredError';
+                err.twoFactorInfo = body.two_factor_info;
+                throw err;
+            }
+            if (body && body.error_type === 'bad_password') {
+                const err = new Error('Bad password');
+                err.name = 'IgLoginBadPasswordError';
+                throw err;
+            }
+            if (body && body.error_type === 'invalid_user') {
+                const err = new Error('Invalid user');
+                err.name = 'IgLoginInvalidUserError';
+                throw err;
+            }
+            if (body && body.message === 'challenge_required') {
+                const err = new Error('Challenge required');
+                err.name = 'IgCheckpointError';
+                err.challengeInfo = body.challenge;
+                throw err;
+            }
+            if (body && body.layout) {
+                const layoutStr = typeof body.layout === 'string' ? body.layout : JSON.stringify(body.layout);
+                // If layout contains two-factor markers, parse and throw
+                if (layoutStr.includes('two_factor_required') || layoutStr.includes('"two_factor_info"')) {
+                    let twoFactorInfo = null;
+                    try {
+                        const match = layoutStr.match(/"two_factor_info"\s*:\s*(\{[^}]+\})/);
+                        if (match)
+                            twoFactorInfo = JSON.parse(match[1]);
+                    }
+                    catch (e) { }
+                    const err = new Error('Two factor authentication required');
+                    err.name = 'IgLoginTwoFactorRequiredError';
+                    err.twoFactorInfo = twoFactorInfo;
+                    throw err;
+                }
+                if (layoutStr.includes('bad_password') || layoutStr.includes('incorrect_password')) {
+                    const err = new Error('Bad password');
+                    err.name = 'IgLoginBadPasswordError';
+                    throw err;
+                }
+                if (layoutStr.includes('invalid_user') || layoutStr.includes('user_not_found')) {
+                    const err = new Error('Invalid user');
+                    err.name = 'IgLoginInvalidUserError';
+                    throw err;
+                }
+                if (layoutStr.includes('challenge_required')) {
+                    const err = new Error('Challenge required');
+                    err.name = 'IgCheckpointError';
+                    err.challengeInfo = body.challenge || null;
+                    throw err;
+                }
+                // Additional attempt to extract token from layout string (redundant but robust)
+                const tokenFromLayout = this._findBearerInString(layoutStr);
+                if (tokenFromLayout) {
+                    this.client.state.authorization = tokenFromLayout;
+                    try {
+                        this.client.state.updateAuthorization();
+                    }
+                    catch (e) { }
+                }
+                // Extract pk (user id) from layout if present
+                const pkPatterns = [
+                    /\\"pk\\":\s*(\d+)/,
+                    /"pk":\s*(\d+)/,
+                    /\\"pk_id\\":\s*\\"(\d+)\\"/,
+                    /"pk_id":\s*"(\d+)"/,
+                    /logged_in_user.*?"pk":\s*(\d+)/,
+                    /logged_in_user.*?\\"pk\\":\s*(\d+)/,
+                ];
+                let extractedPk = null;
+                for (const pattern of pkPatterns) {
+                    const pkMatch = layoutStr.match(pattern);
+                    if (pkMatch) {
+                        extractedPk = pkMatch[1];
+                        this.client.state.cookieUserId = extractedPk;
+                        this.client.state._userId = extractedPk;
+                        break;
+                    }
+                }
+                // Extract IG-Set-WWW-Claim if present
+                const wwwClaimPatterns = [
+                    /IG-Set-WWW-Claim[\\"\s:]+([a-f0-9]+)/i,
+                    /ig-set-www-claim[\\"\s:]+([a-f0-9]+)/i,
+                    /www.claim[\\"\s:]+([a-f0-9]+)/i,
+                    /x-ig-set-www-claim[\\"\s:]+([a-f0-9]+)/i,
+                ];
+                for (const pattern of wwwClaimPatterns) {
+                    const wwwClaimMatch = layoutStr.match(pattern);
+                    if (wwwClaimMatch) {
+                        this.client.state.igWWWClaim = wwwClaimMatch[1];
+                        break;
+                    }
+                }
+                // Extract encryption key id and pub key (already attempted earlier in _extractAndSaveAuthorization)
+                const encKeyIdMatch = layoutStr.match(/IG-Set-Password-Encryption-Key-Id[\\"\s:]+(\d+)/i) ||
+                    layoutStr.match(/password.encryption.key.id[\\"\s:]+(\d+)/i);
+                if (encKeyIdMatch) {
+                    this.client.state.passwordEncryptionKeyId = parseInt(encKeyIdMatch[1]);
+                }
+                const encPubKeyMatch = layoutStr.match(/IG-Set-Password-Encryption-Pub-Key[\\"\s:]+([A-Za-z0-9+\/=]+)/i) ||
+                    layoutStr.match(/password.encryption.pub.key[\\"\s:]+([A-Za-z0-9+\/=]+)/i);
+                if (encPubKeyMatch) {
+                    this.client.state.passwordEncryptionPubKey = encPubKeyMatch[1];
+                }
+                const midMatch = layoutStr.match(/ig-set-x-mid[\\"\s:]+([A-Za-z0-9+\/=_-]+)/i) ||
+                    layoutStr.match(/\\"x-mid\\"[\\"\s:]+([A-Za-z0-9+\/=_-]+)/i);
+                if (midMatch) {
+                    this.client.state.mid = midMatch[1];
+                }
+                // If layout contains a direct logged_in_user JSON, extract and return it
+                const loginResponsePatterns = [
+                    /\\"logged_in_user\\":\{[^}]*\\"pk\\":(\d+)[^}]*\\"username\\":\\"([^"\\]+)\\"/,
+                    /"logged_in_user":\{[^}]*"pk":(\d+)[^}]*"username":"([^"]+)"/,
+                    /\\"logged_in_user\\".*?\\"pk\\":\s*(\d+).*?\\"username\\":\s*\\"([^"\\]+)\\"/s,
+                ];
+                for (const pattern of loginResponsePatterns) {
+                    const loginResponseMatch = layoutStr.match(pattern);
+                    if (loginResponseMatch) {
+                        this.client.state.cookieUserId = loginResponseMatch[1];
+                        this.client.state._userId = loginResponseMatch[1];
+                        return {
+                            pk: parseInt(loginResponseMatch[1]),
+                            pk_id: loginResponseMatch[1],
+                            username: loginResponseMatch[2],
+                        };
+                    }
+                }
+                // If we have extracted a pk and we also have authorization, try to fetch current user
+                if (extractedPk && this.client.state.authorization) {
+                    try {
+                        const userInfo = await this.currentUser();
+                        const user = userInfo.user || userInfo;
+                        if (user && user.pk) {
+                            this.client.state.cookieUserId = String(user.pk);
+                            this.client.state._userId = String(user.pk);
+                        }
+                        return user;
+                    }
+                    catch (e) {
+                        return { pk: parseInt(extractedPk), pk_id: extractedPk };
+                    }
+                }
+            }
+            // If server returned logged_in_user directly in body
+            if (body && body.logged_in_user) {
+                const lu = body.logged_in_user;
+                if (lu.pk) {
+                    this.client.state.cookieUserId = String(lu.pk);
+                    this.client.state._userId = String(lu.pk);
+                }
+                // Ensure authorization is saved if present in response headers
+                this._extractAndSaveAuthorization(response);
+                return lu;
+            }
+            // If we already have authorization, try to fetch current user to populate state
+            if (this.client.state.authorization) {
+                try {
+                    const userInfo = await this.currentUser();
+                    const user = userInfo.user || userInfo;
+                    if (user && user.pk) {
+                        this.client.state.cookieUserId = String(user.pk);
+                        this.client.state._userId = String(user.pk);
+                    }
+                    return user;
+                }
+                catch (e) {
+                    // fallback: return raw body
+                    return body;
+                }
+            }
+            return body;
+        });
+    }
+    async twoFactorLogin(username, verificationCode, twoFactorIdentifier, verificationMethod = '1') {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/two_factor_login/',
+                form: this.client.request.sign({
+                    username,
+                    verification_code: verificationCode,
+                    two_factor_identifier: twoFactorIdentifier,
+                    verification_method: verificationMethod,
+                    trust_this_device: '1',
+                    guid: this.client.state.uuid,
+                    device_id: this.client.state.deviceId,
+                    phone_id: this.client.state.phoneId,
+                }),
+            });
+            // Save authorization if present in two-factor response
+            this._extractAndSaveAuthorization(response);
+            return response.body;
+        });
+    }
+    async logout() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/logout/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async currentUser() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: '/api/v1/accounts/current_user/',
+                qs: { edit: true },
+            });
+            return response.body;
+        });
+    }
+    async accountInfo() {
+        return this.currentUser();
+    }
+    async editProfile({ externalUrl, phoneNumber, username, fullName, biography, email } = {}) {
+        return this.requestWithRetry(async () => {
+            const current = await this.currentUser();
+            const user = current.user || current;
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/edit_profile/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    external_url: externalUrl !== undefined ? externalUrl : (user.external_url || ''),
+                    phone_number: phoneNumber !== undefined ? phoneNumber : (user.phone_number || ''),
+                    username: username !== undefined ? username : user.username,
+                    full_name: fullName !== undefined ? fullName : (user.full_name || ''),
+                    biography: biography !== undefined ? biography : (user.biography || ''),
+                    email: email !== undefined ? email : (user.email || ''),
+                }),
+            });
+            return response.body;
+        });
+    }
+    async setBiography(biography) {
+        return this.editProfile({ biography });
+    }
+    async setExternalUrl(url) {
+        return this.editProfile({ externalUrl: url });
+    }
+    async removeBioLinks() {
+        return this.editProfile({ externalUrl: '' });
+    }
+    async setGender(gender) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/set_gender/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    gender,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async setPrivate() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/set_private/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async setPublic() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/set_public/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async changePassword(oldPassword, newPassword) {
+        const oldEnc = this.encryptPassword(oldPassword);
+        const newEnc = this.encryptPassword(newPassword);
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/change_password/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    enc_old_password: `#PWD_INSTAGRAM:4:${oldEnc.time}:${oldEnc.encrypted}`,
+                    enc_new_password1: `#PWD_INSTAGRAM:4:${newEnc.time}:${newEnc.encrypted}`,
+                    enc_new_password2: `#PWD_INSTAGRAM:4:${newEnc.time}:${newEnc.encrypted}`,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async sendConfirmEmail() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/send_confirm_email/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    send_source: 'edit_profile',
+                }),
+            });
+            return response.body;
+        });
+    }
+    async sendConfirmPhoneNumber(phoneNumber) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/send_confirm_phone_number/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    phone_number: phoneNumber,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async profilePictureChange(uploadId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/change_profile_picture/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    use_fbuploader: 'true',
+                    upload_id: uploadId,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async profilePictureRemove() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/remove_profile_picture/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async newsInbox() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: '/api/v1/news/inbox/',
+            });
+            return response.body;
+        });
+    }
+    async syncLoginExperiments() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/qe/sync/',
+                form: this.client.request.sign({
+                    id: this.client.state.uuid,
+                    server_config_retrieval: '1',
+                    experiments: this.client.state.constants.LOGIN_EXPERIMENTS,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async syncPostLoginExperiments() {
+        let userId;
+        try {
+            userId = this.client.state.cookieUserId;
+        }
+        catch {
+            userId = '0';
+        }
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/qe/sync/',
+                form: this.client.request.sign({
+                    id: userId,
+                    _uid: userId,
+                    _uuid: this.client.state.uuid,
+                    server_config_retrieval: '1',
+                    experiments: this.client.state.constants.EXPERIMENTS,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async syncLauncher(preLogin = true) {
+        const data = {
+            id: this.client.state.uuid,
+            server_config_retrieval: '1',
+        };
+        if (!preLogin) {
+            try {
+                data._uid = this.client.state.cookieUserId;
+                data._uuid = this.client.state.uuid;
+            }
+            catch { }
+        }
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/launcher/sync/',
+                form: this.client.request.sign(data),
+            });
+            return response.body;
+        });
+    }
+    async syncDeviceFeatures() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/devices/sync/',
+                form: this.client.request.sign({
+                    id: this.client.state.uuid,
+                    server_config_retrieval: '1',
+                }),
+            });
+            return response.body;
+        });
+    }
+    async getPrefillCandidates() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/get_prefill_candidates/',
+                form: this.client.request.sign({
+                    android_device_id: this.client.state.deviceId,
+                    phone_id: this.client.state.phoneId,
+                    usages: '["account_recovery_omnibox"]',
+                    device_id: this.client.state.uuid,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async contactPointPrefill(usage = 'prefill') {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/contact_point_prefill/',
+                form: this.client.request.sign({
+                    phone_id: this.client.state.phoneId,
+                    usage,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async getZrToken(params = {}) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: '/api/v1/zr/token/result/',
+                qs: {
+                    device_id: this.client.state.deviceId,
+                    custom_device_id: this.client.state.uuid,
+                    fetch_reason: 'token_expired',
+                    token_hash: '',
+                    ...params,
+                },
+            });
+            return response.body;
+        });
+    }
+    async getConsentSignupConfig() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: '/api/v1/consent/get_signup_config/',
+                qs: {
+                    guid: this.client.state.uuid,
+                    main_account_selected: false,
+                },
+            });
+            return response.body;
+        });
+    }
+    async sendRecoveryFlowEmail(query) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: '/api/v1/accounts/send_recovery_flow_email/',
+                method: 'POST',
+                form: this.client.request.sign({
+                    adid: '',
+                    guid: this.client.state.uuid,
+                    device_id: this.client.state.deviceId,
+                    query,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async sendRecoveryFlowSms(query) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: '/api/v1/accounts/send_recovery_flow_sms/',
+                method: 'POST',
+                form: this.client.request.sign({
+                    adid: '',
+                    guid: this.client.state.uuid,
+                    device_id: this.client.state.deviceId,
+                    query,
+                }),
+            });
+            return response.body;
+        });
+    }
+    static generateAttestParams(state) {
+        // Emulate Instagram's keystore attestation as closely as possible:
+        // - version: 2
+        // - type: "keystore"
+        // - errors: [0]
+        // - challenge_nonce: random base64url
+        // - signed_nonce: ECDSA signature over the nonce
+        // - key_hash: sha256(spki(publicKey))
+        // - certificate_chain: 4 PEM certificates concatenated (leaf + 2 intermediates + root)
+        //
+        // NOTE: This is *not* a real hardware-backed attestation chain, but it mirrors
+        // the structure of the official app very closely so the server sees the same
+        // shape: a single attestation object with a 4‑certificate chain.
+        const challengeNonce = crypto.randomBytes(24).toString('base64url');
+        const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', {
+            namedCurve: 'prime256v1',
+        });
+        // Sign the challenge nonce with the private key (simulating TEE signing).
+        const signedData = crypto.sign(null, Buffer.from(challengeNonce), privateKey);
+        const signedNonce = signedData.toString('base64');
+        const publicKeyDer = publicKey.export({ type: 'spki', format: 'der' });
+        const keyHash = crypto.createHash('sha256').update(publicKeyDer).digest('hex');
+        // Build a 4‑certificate chain (leaf + 2 intermediates + root), just like
+        // what we saw in the captured traffic from the real Instagram app.
+        const leafCertPem = AccountRepository._generateSelfSignedCert(privateKey, publicKey, 'Android Keystore Key');
+        const intermediate1Pem = AccountRepository._generateSelfSignedCert(privateKey, publicKey, 'Android Keystore Key Attestation');
+        const intermediate2Pem = AccountRepository._generateSelfSignedCert(privateKey, publicKey, 'Android Hardware Keystore');
+        const rootCertPem = AccountRepository._generateSelfSignedCert(privateKey, publicKey, 'Android Keystore Root');
+        const certificateChain = [
+            leafCertPem,
+            intermediate1Pem,
+            intermediate2Pem,
+            rootCertPem,
+        ].join('\n');
+        return {
+            attestation: [
+                {
+                    version: 2,
+                    type: 'keystore',
+                    errors: [0],
+                    challenge_nonce: challengeNonce,
+                    signed_nonce: signedNonce,
+                    key_hash: keyHash,
+                    certificate_chain: certificateChain,
+                },
+            ],
+        };
+    }
+    static _generateSelfSignedCert(privateKey, publicKey, cn) {
+        const publicKeyDer = publicKey.export({ type: 'spki', format: 'der' });
+        const serialNumber = crypto.randomBytes(8);
+        const now = new Date();
+        const notBefore = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000);
+        const notAfter = new Date(now.getTime() + 10 * 365 * 24 * 60 * 60 * 1000);
+        const cnBytes = Buffer.from(cn, 'utf8');
+        const cnSeq = Buffer.concat([
+            Buffer.from([0x30, cnBytes.length + 13]),
+            Buffer.from([0x31, cnBytes.length + 11]),
+            Buffer.from([0x30, cnBytes.length + 9]),
+            Buffer.from([0x06, 0x03, 0x55, 0x04, 0x03]),
+            Buffer.from([0x0c, cnBytes.length]),
+            cnBytes,
+        ]);
+        function encodeTime(date) {
+            const str = date.toISOString().replace(/[-:T]/g, '').slice(2, 14) + 'Z';
+            return Buffer.concat([Buffer.from([0x17, str.length]), Buffer.from(str)]);
+        }
+        const validityBuf = Buffer.concat([
+            encodeTime(notBefore),
+            encodeTime(notAfter),
+        ]);
+        const validity = Buffer.concat([Buffer.from([0x30, validityBuf.length]), validityBuf]);
+        const tbs = Buffer.concat([
+            Buffer.from([0xa0, 0x03, 0x02, 0x01, 0x02]),
+            Buffer.from([0x02, serialNumber.length]), serialNumber,
+            Buffer.from([0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02]),
+            cnSeq,
+            validity,
+            cnSeq,
+            publicKeyDer,
+        ]);
+        const tbsSeq = Buffer.concat([Buffer.from([0x30, 0x82]), Buffer.alloc(2), tbs]);
+        tbsSeq.writeUInt16BE(tbs.length, 2);
+        const signature = crypto.sign(null, tbsSeq, privateKey);
+        const sigBitString = Buffer.concat([
+            Buffer.from([0x03, signature.length + 1, 0x00]),
+            signature,
+        ]);
+        const algId = Buffer.from([0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02]);
+        const certBody = Buffer.concat([tbsSeq, algId, sigBitString]);
+        const cert = Buffer.concat([Buffer.from([0x30, 0x82]), Buffer.alloc(2), certBody]);
+        cert.writeUInt16BE(certBody.length, 2);
+        const b64 = cert.toString('base64');
+        const lines = b64.match(/.{1,76}/g) || [b64];
+        return '-----BEGIN CERTIFICATE-----\n' + lines.join('\n') + '\n-----END CERTIFICATE-----';
+    }
+    static createJazoest(input) {
+        const buf = Buffer.from(input || '', 'ascii');
+        let sum = 0;
+        for (let i = 0; i < buf.byteLength; i++) {
+            sum += buf.readUInt8(i);
+        }
+        return `2${sum}`;
+    }
+    encryptPassword(password) {
+        if (!this.client.state.passwordEncryptionPubKey) {
+            return { time: Math.floor(Date.now() / 1000).toString(), encrypted: password };
+        }
+        const randKey = crypto.randomBytes(32);
+        const iv = crypto.randomBytes(12);
+        const rsaEncrypted = crypto.publicEncrypt({
+            key: Buffer.from(this.client.state.passwordEncryptionPubKey, 'base64').toString(),
+            padding: crypto.constants.RSA_PKCS1_PADDING,
+        }, randKey);
+        const cipher = crypto.createCipheriv('aes-256-gcm', randKey, iv);
+        const time = Math.floor(Date.now() / 1000).toString();
+        cipher.setAAD(Buffer.from(time));
+        const aesEncrypted = Buffer.concat([cipher.update(password, 'utf8'), cipher.final()]);
+        const sizeBuffer = Buffer.alloc(2, 0);
+        sizeBuffer.writeInt16LE(rsaEncrypted.byteLength, 0);
+        const authTag = cipher.getAuthTag();
+        return {
+            time,
+            encrypted: Buffer.concat([
+                Buffer.from([1, this.client.state.passwordEncryptionKeyId || 0]),
+                iv,
+                sizeBuffer,
+                rsaEncrypted,
+                authTag,
+                aesEncrypted
+            ]).toString('base64')
+        };
+    }
+    async passwordPublicKeys() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/qe/sync/',
+        });
+        const headers = response.headers || {};
+        const keyId = parseInt(headers['ig-set-password-encryption-key-id'] || '0');
+        const pubKey = headers['ig-set-password-encryption-pub-key'] || '';
+        return { keyId, pubKey };
+    }
+    async setPresenceDisabled(disabled = true) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/set_presence_disabled/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    disabled: disabled ? '1' : '0',
+                }),
+            });
+            return response.body;
+        });
+    }
+    async getCommentFilter() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: '/api/v1/accounts/get_comment_filter/',
+            });
+            return response.body;
+        });
+    }
+    async setCommentFilter(configValue = 0) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/accounts/set_comment_filter/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    config_value: String(configValue),
+                }),
+            });
+            return response.body;
+        });
+    }
+    async pushPreferences(preferences = 'default') {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/push/register/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    device_type: 'android_mqtt',
+                    is_main_push_channel: 'true',
+                    phone_id: this.client.state.phoneId,
+                    device_token: '',
+                    guid: this.client.state.uuid,
+                    users: preferences,
+                }),
+            });
+            return response.body;
+        });
+    }
+}
+module.exports = AccountRepository;