rettiwt-api 5.0.0-alpha.1 → 5.0.0-alpha.2

package/src/services/internal/AuthService.ts

@@ -1,12 +1,9 @@
-import https, { Agent } from 'https';
+import { Agent } from 'https';
 
 import axios from 'axios';
 
-import { HttpsProxyAgent } from 'https-proxy-agent';
-
 import { EApiErrors } from '../../enums/Api';
 import { AuthCredential } from '../../models/auth/AuthCredential';
-import { IRettiwtConfig } from '../../types/RettiwtConfig';
 
 /**
  * The services that handles authentication.
@@ -18,12 +15,10 @@ export class AuthService {
 	private readonly _httpsAgent: Agent;
 
 	/**
-	 * @param config - The config object for configuring the `Rettiwt` instance.
-	 *
-	 * @internal
+	 * @param httpsAgent - The HTTPS agent to use. If none is provided, default is used.
 	 */
-	public constructor(config?: IRettiwtConfig) {
-		this._httpsAgent = config?.proxyUrl ? new HttpsProxyAgent(config.proxyUrl) : new https.Agent();
+	public constructor(httpsAgent?: Agent) {
+		this._httpsAgent = httpsAgent ?? new Agent();
 	}
 
 	/**
@@ -106,11 +101,11 @@ export class AuthService {
 
 		// Getting the guest token
 		await axios
-			.get<{
+			.post<{
 				/* eslint-disable @typescript-eslint/naming-convention */
 				guest_token: string;
 				/* eslint-enable @typescript-eslint/naming-convention */
-			}>('https://api.twitter.com/1.1/guest/activate.json', {
+			}>('https://api.twitter.com/1.1/guest/activate.json', undefined, {
 				headers: cred.toHeader(),
 				httpsAgent: this._httpsAgent,
 			})

package/src/services/internal/TidService.ts

@@ -0,0 +1,147 @@
+import { Agent } from 'http';
+
+import axios from 'axios';
+import * as htmlParser from 'node-html-parser';
+
+import { ELogActions } from '../../enums/Logging';
+
+import { calculateClientTransactionIdHeader } from '../../helper/TidUtils';
+
+import { ITidDynamicArgs } from '../../types/auth/TidDynamicArgs';
+import { ITidProvider } from '../../types/auth/TidProvider';
+
+import { LogService } from './LogService';
+
+/**
+ * Handles transaction ID generation for requests to Twitter.
+ *
+ * @internal
+ */
+export class TidService implements ITidProvider {
+	private readonly _cdnUrl: string;
+	private readonly _httpsAgent: Agent;
+	private readonly _requestHeaders: NonNullable<unknown>;
+	private _dynamicArgs?: ITidDynamicArgs;
+
+	/**
+	 * @param httpsAgent - The HTTPS agent to use. If none is provided, default is used.
+	 */
+	public constructor(httpsAgent?: Agent) {
+		this._cdnUrl = 'https://abs.twimg.com/responsive-web/client-web';
+		this._httpsAgent = httpsAgent ?? new Agent();
+		this._requestHeaders = {
+			/* eslint-disable @typescript-eslint/naming-convention */
+
+			Authority: 'x.com',
+			'Accept-Language': 'en-US,en;q=0.9',
+			'Cache-Control': 'no-cache',
+			Referer: 'https://x.com',
+			'User-Agent':
+				'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36',
+			'X-Twitter-Active-User': 'yes',
+			'X-Twitter-Client-Language': 'en',
+
+			/* eslint-enable @typescript-eslint/naming-convention */
+		};
+	}
+
+	/**
+	 * Fetches the dynamic args embedded in the homepage.
+	 *
+	 * @returns The new dynamic args.
+	 */
+	private async getDynamicArgs(): Promise<ITidDynamicArgs> {
+		const html = await this.getHomepageHtml();
+		const root = htmlParser.parse(html);
+		const keyElement = root.querySelector("[name='twitter-site-verification']");
+		const frameElements = root.querySelectorAll("[id^='loading-x-anim']");
+
+		return {
+			verificationKey: keyElement?.getAttribute('content') ?? '',
+			frames: frameElements.map((el) => this.parseFrameElement(el)),
+			indices: await this.getKeyBytesIndices(html),
+		};
+	}
+
+	/**
+	 * Fetches the HTML content of Twitter's homepage.
+	 *
+	 * @returns The stringified HTML content of the homepage.
+	 */
+	private async getHomepageHtml(): Promise<string> {
+		const response = await axios.get<string>('https://x.com', {
+			headers: this._requestHeaders,
+			httpAgent: this._httpsAgent,
+			httpsAgent: this._httpsAgent,
+		});
+
+		return response.data;
+	}
+
+	private async getKeyBytesIndices(html: string): Promise<number[]> {
+		const ondemandFileMatch = html.match(/ondemand\.s":"([^"]+)"/);
+		if (!ondemandFileMatch || !ondemandFileMatch[1]) {
+			LogService.log(ELogActions.WARNING, { message: 'ondemand.s file not found' });
+
+			return [0, 0, 0, 0];
+		}
+
+		const onDemandFileHash = ondemandFileMatch ? ondemandFileMatch[1] : '';
+		const response = await axios.get<string>(`${this._cdnUrl}/ondemand.s.${onDemandFileHash}a.js`, {
+			httpAgent: this._httpsAgent,
+			httpsAgent: this._httpsAgent,
+		});
+		const match = response.data.matchAll(/(\(\w\[(\d{1,2})],\s*16\))+?/gm);
+
+		return Array.from(match).map((m) => Number(m[2]));
+	}
+
+	private parseFrameElement(element: htmlParser.HTMLElement): number[][] {
+		const pathElement = element.children[0].children[1];
+		const value = pathElement.getAttribute('d');
+		if (!value) {
+			return [[]];
+		}
+
+		const rawFrames = value.substring(9).split('C');
+
+		return rawFrames.map((str) => str.replaceAll(/\D+/g, ' ').trim().split(' ')).map((arr) => arr.map(Number));
+	}
+
+	/**
+	 * Generate an `x-client-transaction-id` for the specific URL method and path.
+	 *
+	 * @param method - The target method.
+	 * @param path - The target path.
+	 *
+	 * @returns The specific `x-client-transaction-id` token.
+	 */
+	public async generate(method: string, path: string): Promise<string | undefined> {
+		try {
+			if (!this._dynamicArgs) {
+				this._dynamicArgs = await this.getDynamicArgs();
+			}
+
+			const { verificationKey, frames, indices } = this._dynamicArgs;
+
+			return calculateClientTransactionIdHeader({
+				keyword: 'obfiowerehiring',
+				method: method,
+				path: path,
+				verificationKey: verificationKey,
+				frames: frames,
+				indices: indices,
+				extraByte: 3,
+			});
+		} catch {
+			return;
+		}
+	}
+
+	/**
+	 * Refreshes the dynamic args from the homepage.
+	 */
+	public async refreshDynamicArgs(): Promise<void> {
+		this._dynamicArgs = await this.getDynamicArgs();
+	}
+}

package/src/services/public/FetcherService.ts

@@ -1,8 +1,5 @@
-import https, { Agent } from 'https';
-
 import axios from 'axios';
 import { Cookie } from 'cookiejar';
-import { HttpsProxyAgent } from 'https-proxy-agent';
 
 import { allowGuestAuthentication, fetchResources, postResources } from '../../collections/Groups';
 import { requests } from '../../collections/Requests';
@@ -12,14 +9,17 @@ import { EResourceType } from '../../enums/Resource';
 import { FetchArgs } from '../../models/args/FetchArgs';
 import { PostArgs } from '../../models/args/PostArgs';
 import { AuthCredential } from '../../models/auth/AuthCredential';
+import { RettiwtConfig } from '../../models/RettiwtConfig';
 import { IFetchArgs } from '../../types/args/FetchArgs';
 import { IPostArgs } from '../../types/args/PostArgs';
+import { ITidHeader } from '../../types/auth/TidHeader';
+import { ITidProvider } from '../../types/auth/TidProvider';
 import { IErrorHandler } from '../../types/ErrorHandler';
-import { IRettiwtConfig } from '../../types/RettiwtConfig';
 
 import { AuthService } from '../internal/AuthService';
 import { ErrorService } from '../internal/ErrorService';
 import { LogService } from '../internal/LogService';
+import { TidService } from '../internal/TidService';
 
 /**
  * The base service that handles all HTTP requests.
@@ -27,43 +27,35 @@ import { LogService } from '../internal/LogService';
  * @public
  */
 export class FetcherService {
-	/** The api key to use for authenticating against Twitter API as user. */
-	private readonly _apiKey?: string;
+	/** The AuthService instance to use. */
+	private readonly _auth: AuthService;
 
-	/** Custom headers to use for all requests */
-	private readonly _customHeaders?: { [key: string]: string };
+	/** The delay/delay function to use (ms). */
+	private readonly _delay?: number | (() => number | Promise<number>);
 
 	/** The service used to handle HTTP and API errors */
 	private readonly _errorHandler: IErrorHandler;
 
-	/** The guest key to use for authenticating against Twitter API as guest. */
-	private readonly _guestKey?: string;
-
-	/** The URL To the proxy server to use for all others. */
-	private readonly _proxyUrl?: URL;
+	/** Service responsible for generating the `x-client-transaction-id` header. */
+	private readonly _tidProvider: ITidProvider;
 
 	/** The max wait time for a response. */
 	private readonly _timeout: number;
 
-	/** The URL to the proxy server to use only for authentication. */
-	protected readonly authProxyUrl?: URL;
-
-	/** The id of the authenticated user (if any). */
-	protected readonly userId?: string;
+	/** The config object. */
+	protected readonly config: RettiwtConfig;
 
 	/**
 	 * @param config - The config object for configuring the Rettiwt instance.
 	 */
-	public constructor(config?: IRettiwtConfig) {
-		LogService.enabled = config?.logging ?? false;
-		this._apiKey = config?.apiKey;
-		this._guestKey = config?.guestKey;
-		this.userId = config?.apiKey ? AuthService.getUserId(config.apiKey) : undefined;
-		this.authProxyUrl = config?.authProxyUrl ?? config?.proxyUrl;
-		this._proxyUrl = config?.proxyUrl;
-		this._timeout = config?.timeout ?? 0;
-		this._errorHandler = config?.errorHandler ?? new ErrorService();
-		this._customHeaders = config?.headers;
+	public constructor(config: RettiwtConfig) {
+		LogService.enabled = config.logging ?? false;
+		this.config = config;
+		this._delay = config.delay;
+		this._errorHandler = config.errorHandler ?? new ErrorService();
+		this._tidProvider = config.tidProvider ?? new TidService(config.httpsAgent);
+		this._timeout = config.timeout ?? 0;
+		this._auth = new AuthService(config.httpsAgent);
 	}
 
 	/**
@@ -75,10 +67,10 @@ export class FetcherService {
 	 */
 	private checkAuthorization(resource: EResourceType): void {
 		// Logging
-		LogService.log(ELogActions.AUTHORIZATION, { authenticated: this.userId != undefined });
+		LogService.log(ELogActions.AUTHORIZATION, { authenticated: this.config.userId != undefined });
 
 		// Checking authorization status
-		if (!allowGuestAuthentication.includes(resource) && this.userId == undefined) {
+		if (!allowGuestAuthentication.includes(resource) && this.config.userId == undefined) {
 			throw new Error(EApiErrors.RESOURCE_NOT_ALLOWED);
 		}
 	}
@@ -89,46 +81,46 @@ export class FetcherService {
 	 * @returns The generated AuthCredential
 	 */
 	private async getCredential(): Promise<AuthCredential> {
-		if (this._apiKey) {
+		if (this.config.apiKey) {
 			// Logging
 			LogService.log(ELogActions.GET, { target: 'USER_CREDENTIAL' });
 
 			return new AuthCredential(
-				AuthService.decodeCookie(this._apiKey)
+				AuthService.decodeCookie(this.config.apiKey)
 					.split(';')
 					.map((item) => new Cookie(item)),
 			);
-		} else if (this._guestKey) {
-			// Logging
-			LogService.log(ELogActions.GET, { target: 'GUEST_CREDENTIAL' });
-
-			return new AuthCredential(undefined, this._guestKey);
 		} else {
 			// Logging
 			LogService.log(ELogActions.GET, { target: 'NEW_GUEST_CREDENTIAL' });
 
-			return await new AuthService({ proxyUrl: this.authProxyUrl }).guest();
+			return this._auth.guest();
 		}
 	}
 
 	/**
-	 * Gets the https agent based on whether a proxy is used or not.
+	 * Generates the header for the transaction ID.
 	 *
-	 * @param proxyUrl - Optional URL with proxy configuration to use for requests to Twitter API.
+	 * @param method - The target method.
+	 * @param url - The target URL.
 	 *
-	 * @returns The https agent to use.
+	 * @returns The header containing the transaction ID.
 	 */
-	private getHttpsAgent(proxyUrl?: URL): Agent {
-		if (proxyUrl) {
-			// Logging
-			LogService.log(ELogActions.GET, { target: 'HTTPS_PROXY_AGENT' });
-
-			return new HttpsProxyAgent(proxyUrl);
+	private async getTransactionHeader(method: string, url: string): Promise<ITidHeader | undefined> {
+		// Getting the URL path excluding all params
+		const path = new URL(url).pathname.split('?')[0].trim();
+
+		// Generating the transaction ID
+		const tid = await this._tidProvider.generate(method.toUpperCase(), path);
+
+		if (tid) {
+			return {
+				/* eslint-disable @typescript-eslint/naming-convention */
+				'x-client-transaction-id': tid,
+				/* eslint-enable @typescript-eslint/naming-convention */
+			};
 		} else {
-			// Logging
-			LogService.log(ELogActions.GET, { target: 'HTTPS_AGENT' });
-
-			return new https.Agent();
+			return undefined;
 		}
 	}
 
@@ -154,6 +146,29 @@ export class FetcherService {
 		}
 	}
 
+	/**
+	 * Introduces a delay using the configured delay/delay function.
+	 */
+	private async wait(): Promise<void> {
+		// If no delay is set, skip
+		if (this._delay == undefined) {
+			return;
+		}
+
+		/** The delay (in ms) to use. */
+		let delay = 0;
+
+		// Getting the delay
+		if (this._delay && typeof this._delay == 'number') {
+			delay = this._delay;
+		} else if (this._delay && typeof this._delay == 'function') {
+			delay = await this._delay();
+		}
+
+		// Awaiting for the delay time
+		await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+
 	/**
 	 * Makes an HTTP request according to the given parameters.
 	 *
@@ -182,7 +197,7 @@ export class FetcherService {
 	 * })
 	 * ```
 	 */
-	public async request<T>(resource: EResourceType, args: IFetchArgs | IPostArgs): Promise<T> {
+	public async request<T = unknown>(resource: EResourceType, args: IFetchArgs | IPostArgs): Promise<T> {
 		// Logging
 		LogService.log(ELogActions.REQUEST, { resource: resource, args: args });
 
@@ -192,9 +207,6 @@ export class FetcherService {
 		// Validating args
 		args = this.validateArgs(resource, args)!;
 
-		// Getting HTTPS agent
-		const httpsAgent: Agent = this.getHttpsAgent(this._proxyUrl);
-
 		// Getting credentials from key
 		const cred: AuthCredential = await this.getCredential();
 
@@ -202,13 +214,21 @@ export class FetcherService {
 		const config = requests[resource](args);
 
 		// Setting additional request parameters
-		config.headers = { ...config.headers, ...cred.toHeader(), ...(this._customHeaders || {}) };
-		config.httpAgent = httpsAgent;
-		config.httpsAgent = httpsAgent;
+		config.headers = {
+			...config.headers,
+			...cred.toHeader(),
+			...(await this.getTransactionHeader(config.method ?? '', config.url ?? '')),
+			...this.config.headers,
+		};
+		config.httpAgent = this.config.httpsAgent;
+		config.httpsAgent = this.config.httpsAgent;
 		config.timeout = this._timeout;
 
 		// Sending the request
 		try {
+			// Introducing a delay
+			await this.wait();
+
 			// Returning the reponse body
 			return (await axios<T>(config)).data;
 		} catch (error) {

package/src/services/public/ListService.ts

@@ -1,11 +1,11 @@
-import { IListMembersResponse, IListTweetsResponse } from 'rettiwt-core';
-
 import { extractors } from '../../collections/Extractors';
 import { EResourceType } from '../../enums/Resource';
 import { CursoredData } from '../../models/data/CursoredData';
 import { Tweet } from '../../models/data/Tweet';
 import { User } from '../../models/data/User';
-import { IRettiwtConfig } from '../../types/RettiwtConfig';
+import { RettiwtConfig } from '../../models/RettiwtConfig';
+import { IListMembersResponse } from '../../types/raw/list/Members';
+import { IListTweetsResponse } from '../../types/raw/list/Tweets';
 
 import { FetcherService } from './FetcherService';
 
@@ -15,7 +15,7 @@ export class ListService extends FetcherService {
 	 *
 	 * @internal
 	 */
-	public constructor(config?: IRettiwtConfig) {
+	public constructor(config: RettiwtConfig) {
 		super(config);
 	}
 

package/src/services/public/TweetService.ts

@@ -1,31 +1,30 @@
 import { statSync } from 'fs';
 
-import {
-	ESearchResultType,
-	IInitializeMediaUploadResponse,
-	IListTweetsResponse,
-	INewTweet,
-	ITweetDetailsResponse,
-	ITweetLikeResponse,
-	ITweetPostResponse,
-	ITweetRepliesResponse,
-	ITweetRetweetersResponse,
-	ITweetRetweetResponse,
-	ITweetScheduleResponse,
-	ITweetSearchResponse,
-	ITweetUnlikeResponse,
-	ITweetUnpostResponse,
-	ITweetUnretweetResponse,
-	ITweetUnscheduleResponse,
-	TweetFilter,
-} from 'rettiwt-core';
-
 import { extractors } from '../../collections/Extractors';
 import { EResourceType } from '../../enums/Resource';
 import { CursoredData } from '../../models/data/CursoredData';
 import { Tweet } from '../../models/data/Tweet';
 import { User } from '../../models/data/User';
-import { IRettiwtConfig } from '../../types/RettiwtConfig';
+
+import { RettiwtConfig } from '../../models/RettiwtConfig';
+import { ITweetFilter } from '../../types/args/FetchArgs';
+import { INewTweet } from '../../types/args/PostArgs';
+import { IListTweetsResponse } from '../../types/raw/list/Tweets';
+import { IMediaInitializeUploadResponse } from '../../types/raw/media/InitalizeUpload';
+import { ITweetDetailsResponse } from '../../types/raw/tweet/Details';
+
+import { ITweetLikeResponse } from '../../types/raw/tweet/Like';
+import { ITweetLikersResponse } from '../../types/raw/tweet/Likers';
+import { ITweetPostResponse } from '../../types/raw/tweet/Post';
+import { ITweetRepliesResponse } from '../../types/raw/tweet/Replies';
+import { ITweetRetweetResponse } from '../../types/raw/tweet/Retweet';
+import { ITweetRetweetersResponse } from '../../types/raw/tweet/Retweeters';
+import { ITweetScheduleResponse } from '../../types/raw/tweet/Schedule';
+import { ITweetSearchResponse } from '../../types/raw/tweet/Search';
+import { ITweetUnlikeResponse } from '../../types/raw/tweet/Unlike';
+import { ITweetUnpostResponse } from '../../types/raw/tweet/Unpost';
+import { ITweetUnretweetResponse } from '../../types/raw/tweet/Unretweet';
+import { ITweetUnscheduleResponse } from '../../types/raw/tweet/Unschedule';
 
 import { FetcherService } from './FetcherService';
 
@@ -40,14 +39,14 @@ export class TweetService extends FetcherService {
 	 *
 	 * @internal
 	 */
-	public constructor(config?: IRettiwtConfig) {
+	public constructor(config: RettiwtConfig) {
 		super(config);
 	}
 
 	/**
 	 * Get the details of a tweet.
 	 *
-	 * @param id - The id of the target tweet.
+	 * @param id - The id(s) of the target tweet/tweets.
 	 *
 	 * @returns
 	 * The details of the tweet with the given id.
@@ -70,11 +69,11 @@ export class TweetService extends FetcherService {
 	 * });
 	 * ```
 	 */
-	public async details(id: string): Promise<Tweet | undefined> {
+	public async details<T extends string | string[]>(id: T): Promise<T extends string ? Tweet | undefined : Tweet[]> {
 		let resource: EResourceType;
 
-		// If user is authenticated
-		if (this.userId != undefined) {
+		// If user is authenticated and details of single tweet required
+		if (this.config.userId != undefined && typeof id == 'string') {
 			resource = EResourceType.TWEET_DETAILS_ALT;
 
 			// Fetching raw tweet details
@@ -83,19 +82,31 @@ export class TweetService extends FetcherService {
 			// Deserializing response
 			const data = extractors[resource](response, id);
 
-			return data;
+			return data as T extends string ? Tweet | undefined : Tweet[];
+		}
+		// If user is authenticated and details of multiple tweets required
+		else if (this.config.userId != undefined && Array.isArray(id)) {
+			resource = EResourceType.TWEET_DETAILS_BULK;
+
+			// Fetching raw tweet details
+			const response = await this.request<ITweetRepliesResponse>(resource, { ids: id });
+
+			// Deserializing response
+			const data = extractors[resource](response, id);
+
+			return data as T extends string ? Tweet | undefined : Tweet[];
 		}
 		// If user is not authenticated
 		else {
 			resource = EResourceType.TWEET_DETAILS;
 
 			// Fetching raw tweet details
-			const response = await this.request<ITweetDetailsResponse>(resource, { id: id });
+			const response = await this.request<ITweetDetailsResponse>(resource, { id: String(id) });
 
 			// Deserializing response
-			const data = extractors[resource](response, id);
+			const data = extractors[resource](response, String(id));
 
-			return data;
+			return data as T extends string ? Tweet | undefined : Tweet[];
 		}
 	}
 
@@ -137,6 +148,48 @@ export class TweetService extends FetcherService {
 		return data;
 	}
 
+	/**
+	 * Get the list of users who liked a tweet. Only works for your own tweets.
+	 *
+	 * @param id - The id of the target tweet.
+	 * @param count - The number of likers to fetch, must be \<= 100.
+	 * @param cursor - The cursor to the batch of likers to fetch.
+	 *
+	 * @returns The list of users who liked the given tweet.
+	 *
+	 * @example
+	 * ```
+	 * import { Rettiwt } from 'rettiwt-api';
+	 *
+	 * // Creating a new Rettiwt instance using the given 'API_KEY'
+	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+	 *
+	 * // Fetching the most recent 100 likers of the Tweet with id '1234567890'
+	 * rettiwt.tweet.likers('1234567890')
+	 * .then(res => {
+	 * 	console.log(res);
+	 * })
+	 * .catch(err => {
+	 * 	console.log(err);
+	 * });
+	 * ```
+	 */
+	public async likers(id: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
+		const resource = EResourceType.TWEET_LIKERS;
+
+		// Fetching raw likers
+		const response = await this.request<ITweetLikersResponse>(resource, {
+			id: id,
+			count: count,
+			cursor: cursor,
+		});
+
+		// Deserializing response
+		const data = extractors[resource](response);
+
+		return data;
+	}
+
 	/**
 	 * Get the list of tweets from a tweet list.
 	 *
@@ -462,12 +515,7 @@ export class TweetService extends FetcherService {
 	 *
 	 * @remarks For details about available filters, refer to {@link TweetFilter}
 	 */
-	public async search(
-		filter: TweetFilter,
-		count?: number,
-		cursor?: string,
-		results?: ESearchResultType,
-	): Promise<CursoredData<Tweet>> {
+	public async search(filter: ITweetFilter, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
 		const resource = EResourceType.TWEET_SEARCH;
 
 		// Fetching raw list of filtered tweets
@@ -475,7 +523,6 @@ export class TweetService extends FetcherService {
 			filter: filter,
 			count: count,
 			cursor: cursor,
-			results: results,
 		});
 
 		// Deserializing response
@@ -519,7 +566,7 @@ export class TweetService extends FetcherService {
 	 * streamTweets();
 	 * ```
 	 */
-	public async *stream(filter: TweetFilter, pollingInterval = 60000): AsyncGenerator<Tweet> {
+	public async *stream(filter: ITweetFilter, pollingInterval = 60000): AsyncGenerator<Tweet> {
 		const startDate = new Date();
 
 		let cursor: string | undefined = undefined;
@@ -545,7 +592,7 @@ export class TweetService extends FetcherService {
 
 			// If there are more tweets to fetch, adjust the cursor value
 			if (tweets.list.length > 0 && tweets.next) {
-				cursor = tweets.next.value;
+				cursor = tweets.next;
 			}
 			// Else, start the next iteration from this batch's most recent tweet
 			else {
@@ -732,7 +779,7 @@ export class TweetService extends FetcherService {
 		// INITIALIZE
 		const size = typeof media == 'string' ? statSync(media).size : media.byteLength;
 		const id: string = (
-			await this.request<IInitializeMediaUploadResponse>(EResourceType.MEDIA_UPLOAD_INITIALIZE, {
+			await this.request<IMediaInitializeUploadResponse>(EResourceType.MEDIA_UPLOAD_INITIALIZE, {
 				upload: { size: size },
 			})
 		).media_id_string;