nodejs-insta-private-api-mqt 1.3.85 → 1.3.87

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

@@ -1,1384 +0,0 @@
-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) {
-    try {
-      const result = await requestFn();
-      return result;
-    } catch (error) {
-      const shouldRetry =
-        (error.data?.error_type === 'server_error' ||
-         error.data?.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) {
-    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 (body?.layout?.bloks_payload) {
-          layoutStr = JSON.stringify(body.layout.bloks_payload);
-        } else if (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;