Adds Fetch/Ping for Blocked Users during CSFloat Market Trades

Author: Step7750

package-lock.json

@@ -0,0 +1,49 @@
+import {Trade} from '../types/float_market';
+import {gStore} from '../storage/store';
+import {StorageKey} from '../storage/keys';
+import {FetchSteamUser} from '../bridge/handlers/fetch_steam_user';
+import {FetchBlockedUsers} from '../bridge/handlers/fetch_blocked_users';
+import {PingBlockedUsers} from '../bridge/handlers/ping_blocked_users';
+
+export async function reportBlockedBuyers(pendingTrades: Trade[]) {
+    const lastPing = await gStore.getWithStorage<number>(
+        chrome.storage.local,
+        StorageKey.LAST_TRADE_BLOCKED_PING_ATTEMPT
+    );
+    if (lastPing && lastPing > Date.now() - 10 * 60 * 1000) {
+        // Report blocked users at most once every 10 minutes
+        return;
+    }
+
+    await gStore.setWithStorage<number>(chrome.storage.local, StorageKey.LAST_TRADE_BLOCKED_PING_ATTEMPT, Date.now());
+
+    const steamUser = await FetchSteamUser.handleRequest({}, {});
+    if (!steamUser.sessionID || !steamUser.steamID) {
+        return;
+    }
+
+    const hasTrade = pendingTrades.some((e) => e.seller_id === steamUser.steamID || e.buyer_id === steamUser.steamID);
+    if (!hasTrade) {
+        // Logged-in user on Steam doesn't have any CSFloat trades, not relevant
+        return;
+    }
+
+    const {blocked_steam_ids} = await FetchBlockedUsers.handleRequest(
+        {
+            steam_id: steamUser.steamID,
+        },
+        {}
+    );
+
+    const filteredIDs = blocked_steam_ids.filter((steamID) => {
+        // Is it a buyer or seller in one of the trades?
+        return pendingTrades.some((e) => e.seller_id == steamID || e.buyer_id == steamID);
+    });
+
+    if (filteredIDs.length === 0) {
+        // Nothing to report
+        return;
+    }
+
+    await PingBlockedUsers.handleRequest({blocked_steam_ids: filteredIDs}, {});
+}

src/lib/alarms/blocked_users.ts

@@ -7,6 +7,7 @@ import {PingExtensionStatus} from '../bridge/handlers/ping_extension_status';
 import {AccessToken, getAccessToken} from './access_token';
 import {gStore} from '../storage/store';
 import {StorageKey} from '../storage/keys';
+import {reportBlockedBuyers} from './blocked_users';
 
 export const PING_CSFLOAT_TRADE_STATUS_ALARM_NAME = 'ping_csfloat_trade_status_alarm';
 
@@ -67,11 +68,19 @@ export async function pingTradeStatus(expectedSteamID?: string) {
 interface UpdateErrors {
     history_error?: string;
     trade_offer_error?: string;
+    blocked_buyers_error?: string;
 }
 
 async function pingUpdates(pendingTrades: Trade[]): Promise<UpdateErrors> {
     const errors: UpdateErrors = {};
 
+    try {
+        await reportBlockedBuyers(pendingTrades);
+    } catch (e) {
+        console.error('failed to report blocked buyers', e);
+        errors.blocked_buyers_error = (e as any).toString();
+    }
+
     try {
         await cancelUnconfirmedTradeOffers(pendingTrades);
     } catch (e) {

src/lib/alarms/csfloat_trade_pings.ts

@@ -0,0 +1,38 @@
+import {SimpleHandler} from './main';
+import {RequestType} from './types';
+
+interface FetchBlockedUsersRequest {
+    // Steam ID to use to fetch who they've blocked. If this doesn't match the logged
+    // in user, then an error will be thrown.
+    steam_id: string;
+}
+
+interface FetchBlockedUsersResponse {
+    blocked_steam_ids: string[];
+}
+
+export const FetchBlockedUsers = new SimpleHandler<FetchBlockedUsersRequest, FetchBlockedUsersResponse>(
+    RequestType.FETCH_BLOCKED_USERS,
+    async (req) => {
+        const resp = await fetch(
+            `https://steamcommunity.com/profiles/${req.steam_id}/friends/blocked?ajax=1&l=english`
+        );
+        if (!resp.ok) {
+            throw new Error('non-ok response for blocked users');
+        }
+
+        const text = await resp.text();
+
+        if (!text.toLowerCase().includes('blocked')) {
+            throw new Error('failed to parse blocked users, requested steam id might not be logged in');
+        }
+
+        const matches = text.matchAll(/class=".+?ignored.+?".*?id=".+?".*?data-steamid="(7656\d+)"/gs);
+
+        const blocked_steam_ids = [...matches].map((match) => {
+            return match[1];
+        });
+
+        return {blocked_steam_ids};
+    }
+);

src/lib/bridge/handlers/fetch_blocked_users.ts

@@ -24,6 +24,8 @@ import {PingStatus} from './ping_status';
 import {FetchOwnInventory} from './fetch_own_inventory';
 import {CancelTradeOffer} from './cancel_trade_offer';
 import {FetchSteamTrades} from './fetch_steam_trades';
+import {FetchBlockedUsers} from './fetch_blocked_users';
+import {PingBlockedUsers} from './ping_blocked_users';
 
 export const HANDLERS_MAP: {[key in RequestType]: RequestHandler<any, any>} = {
     [RequestType.EXECUTE_SCRIPT_ON_PAGE]: ExecuteScriptOnPage,
@@ -50,4 +52,6 @@ export const HANDLERS_MAP: {[key in RequestType]: RequestHandler<any, any>} = {
     [RequestType.FETCH_OWN_INVENTORY]: FetchOwnInventory,
     [RequestType.CANCEL_TRADE_OFFER]: CancelTradeOffer,
     [RequestType.FETCH_STEAM_TRADES]: FetchSteamTrades,
+    [RequestType.FETCH_BLOCKED_USERS]: FetchBlockedUsers,
+    [RequestType.PING_BLOCKED_USERS]: PingBlockedUsers,
 };

src/lib/bridge/handlers/handlers.ts

@@ -0,0 +1,29 @@
+import {SimpleHandler} from './main';
+import {RequestType} from './types';
+import {environment} from '../../../environment';
+
+export interface PingBlockedUsersRequest {
+    blocked_steam_ids: string[];
+}
+
+export interface PingBlockedUsersResponse {}
+
+export const PingBlockedUsers = new SimpleHandler<PingBlockedUsersRequest, PingBlockedUsersResponse>(
+    RequestType.PING_BLOCKED_USERS,
+    async (req) => {
+        const resp = await fetch(`${environment.csfloat_base_api_url}/v1/trades/steam-status/blocked-users`, {
+            credentials: 'include',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(req),
+        });
+
+        if (resp.status !== 200) {
+            throw new Error('invalid status');
+        }
+
+        return {};
+    }
+);

src/lib/bridge/handlers/ping_blocked_users.ts

@@ -23,4 +23,6 @@ export enum RequestType {
     FETCH_OWN_INVENTORY = 21,
     CANCEL_TRADE_OFFER = 22,
     FETCH_STEAM_TRADES = 23,
+    FETCH_BLOCKED_USERS = 24,
+    PING_BLOCKED_USERS = 25,
 }

src/lib/bridge/handlers/types.ts

@@ -10,6 +10,7 @@ export enum StorageKey {
     GLOBAL_FILTERS = 'global',
     ACCESS_TOKEN = 'access_token',
     LAST_TRADE_PING_ATTEMPT = 'last_trade_ping_attempt',
+    LAST_TRADE_BLOCKED_PING_ATTEMPT = 'last_trade_blocked_ping_attempt',
 }
 
 export type DynamicStorageKey = string;

src/lib/storage/keys.ts

@@ -104,4 +104,6 @@ export interface Trade {
     trade_url: string;
     steam_offer: SteamOffer;
     wait_for_cancel_ping?: boolean;
+    seller_blocked_buyer_at?: string;
+    buyer_blocked_seller_at?: string;
 }