core-3nweb-client-lib 0.50.6 → 0.52.0

package/build/api-defs/asmail.d.ts

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2016, 2020, 2022, 2024 - 2025 3NSoft Inc.
+ Copyright (C) 2016, 2020, 2022, 2024 - 2026 3NSoft Inc.
 
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -34,6 +34,10 @@ declare namespace web3n.asmail {
 
 		config: ASMailConfigService;
 
+		getReportAddressForDomain(domain: string): Promise<string>;
+
+		filter: ASMailFilter;
+
 	}
 
 	interface PreFlightOnlyService {
@@ -307,6 +311,7 @@ declare namespace web3n.asmail {
 	interface ASMailSendException extends RuntimeException {
 		type: 'asmail-delivery';
 		address?: string;
+		id?: string;
 		
 		// errors that are due to remote side,
 		// these will be placed into ProgressDelivery object
@@ -319,10 +324,11 @@ declare namespace web3n.asmail {
 		allowedSize?: number;
 		recipientHasNoPubKey?: true;
 		recipientPubKeyFailsValidation?: true;
-		msgNotFound?: true;
 		
 		// errors that are due to this side
 		msgCancelled?: true;
+		recipientBlocked?: true;
+		msgNotFound?: true;
 	}
 
 	interface ASMailConfigService {
@@ -378,7 +384,7 @@ declare namespace web3n.asmail {
 	 */
 	interface AddressesList {
 		[address: string]: number;
-	}	
+	}
 
 	/**
 	 * Invites list is a map from invites to respective maximum message size in
@@ -386,6 +392,25 @@ declare namespace web3n.asmail {
 	 */
 	interface InvitesList {
 		[invite: string]: number;
-	}	
+	}
+
+	interface ASMailFilter {
+		listRules(): Promise<FilteringRule[]>;
+		addRule(rule: FilteringRule): Promise<{ ruleIndex: number; rule: FilteringRule; }>;
+		removeRule(ruleIndex: number, rule: FilteringRule): Promise<boolean>;
+	}
+
+	interface BlockAddressRule {
+		ruleType: 'block-address';
+		domain: string;
+		username: string;
+	}
+
+	interface BlockDomainRule {
+		ruleType: 'block-domain';
+		domain: string;
+	}
+
+	type FilteringRule = BlockAddressRule | BlockDomainRule;
 
 }

package/build/api-defs/files.d.ts

@@ -70,6 +70,7 @@ declare namespace web3n.files {
 		type: 'fs-sync';
 		path: string;
 		localVersion?: number;
+		uploadVersion?: number;
 		remoteVersion?: number;
 		alreadyUploading?: true;
 		uploadTaskId?: number;
@@ -1681,8 +1682,8 @@ declare namespace web3n.files {
 		upload(path: string, opts?: OptionsToUploadLocal): Promise<number|undefined>;
 
 		/**
-		 * This method is for resolving conflicts on folders.
-		 * It adopts given folder item, that is present in remote version and is missing in local version.
+		 * This method is for resolving conflicts on folders, an action item by item.
+		 * It adopts only given folder item, that is present in remote version and is missing in local version.
 		 * Returns new local version.
 		 * @param path 
 		 * @param remoteItemName 
@@ -1694,7 +1695,9 @@ declare namespace web3n.files {
 
 		/**
 		 * This method is for resolving conflicts on folders.
-		 * It absorbs folder changes done in remote version.
+		 * It completely absorbs folder changes done in remote version.
+		 * Such wholesome may or may not be appriate in all circumstances, so use `adoptRemoteFolderItem`
+		 * for a more nuanced item-by-item operations.
 		 * Returns new local version, if there were remote items to adopt and their were added to local state.
 		 * @param path 
 		 * @param opts

package/build/core/asmail/asmail-cap-ipc.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020 - 2023, 2025 3NSoft Inc.
+ Copyright (C) 2020 - 2023, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -58,7 +58,9 @@ function exposeASMailCAP(cap, expServices) {
                 removeMsg: removeMsg.wrapService(box.removeMsg),
                 subscribe: inboxSubscribe.wrapService(box.subscribe, expServices)
             },
-            config: exposeConfigCAP(cap.config)
+            config: exposeConfigCAP(cap.config),
+            getReportAddressForDomain: (0, service_side_wrap_1.wrapReqReplyFunc)(cap, cap.getReportAddressForDomain),
+            filter: exposeFilterCAP(cap.filter)
         };
     }
 }
@@ -83,7 +85,9 @@ function makeASMailBasedOnListing(caller, objPath, capLists) {
                 removeMsg: removeMsg.makeCaller(caller, inboxPath),
                 subscribe: inboxSubscribe.makeCaller(caller, inboxPath)
             },
-            config: makeConfigCaller(caller, objPath.concat('config'))
+            config: makeConfigCaller(caller, objPath.concat('config')),
+            getReportAddressForDomain: (0, caller_side_wrap_1.makeReqRepFuncCaller)(caller, objPath.concat('getReportAddressForDomain')),
+            filter: makeFilterCaller(caller, objPath.concat('filter'))
         };
     }
     else if (capLists === 'preflight') {
@@ -612,4 +616,21 @@ function makeConfigCaller(caller, objPath) {
         setOnServer: callConfig(caller, objPath, 'setOnServer')
     };
 }
+function exposeFilterCAP(cap) {
+    return {
+        addRule: (0, service_side_wrap_1.wrapReqReplySrvMethod)(cap, 'addRule'),
+        listRules: (0, service_side_wrap_1.wrapReqReplySrvMethod)(cap, 'listRules'),
+        removeRule: (0, service_side_wrap_1.wrapReqReplySrvMethod)(cap, 'removeRule')
+    };
+}
+function callFilder(caller, objPath, method) {
+    return (0, caller_side_wrap_1.makeReqRepObjCaller)(caller, objPath, method);
+}
+function makeFilterCaller(caller, objPath) {
+    return {
+        addRule: callFilder(caller, objPath, 'addRule'),
+        listRules: callFilder(caller, objPath, 'listRules'),
+        removeRule: callFilder(caller, objPath, 'removeRule')
+    };
+}
 Object.freeze(exports);

package/build/core/asmail/delivery/common.d.ts

@@ -14,6 +14,7 @@ type AttachmentsContainer = web3n.asmail.AttachmentsContainer;
 type FS = web3n.files.FS;
 type WritableFS = web3n.files.WritableFS;
 type JsonKey = web3n.keys.JsonKey;
+type ASMailSendException = web3n.asmail.ASMailSendException;
 export declare class Attachments {
     container: AttachmentsContainer | undefined;
     fs: FS | undefined;
@@ -66,6 +67,7 @@ export interface ResourcesForSending {
          * @param address
          */
         newParamsForSendingReplies: (address: string) => Promise<SendingParams | undefined>;
+        isAddressBlocked(address: string): boolean;
     };
     cryptor: AsyncSBoxCryptor;
     random: AsyncRNG;
@@ -79,4 +81,5 @@ export interface SavedMsgToSend {
     recipients: string[];
     retryOpts: DeliveryOptions['retryRecipient'];
 }
+export declare function makeDeliveryException(params: Partial<ASMailSendException>): ASMailSendException;
 export {};

package/build/core/asmail/delivery/common.js

@@ -18,8 +18,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SEG_SIZE_IN_K_QUATS = exports.Attachments = void 0;
 exports.estimatePackedSizeOf = estimatePackedSizeOf;
+exports.makeDeliveryException = makeDeliveryException;
 const attachments_container_1 = require("../msg/attachments-container");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const runtime_1 = require("../../../lib-common/exceptions/runtime");
 const ATTACHMENTS_NAME = 'attachments';
 class Attachments {
     constructor(container, fs) {
@@ -138,4 +140,7 @@ function estimatePackedSizeOf(size) {
     }
     return 148 + numOfCompleteSegs * exports.SEG_SIZE_IN_K_QUATS * 256 + lastSegSize;
 }
+function makeDeliveryException(params) {
+    return (0, runtime_1.makeRuntimeException)('asmail-delivery', params, {});
+}
 Object.freeze(exports);

package/build/core/asmail/delivery/index.js

@@ -104,12 +104,7 @@ class Delivery {
         const msg = this.msgs.get(id);
         if (!msg) {
             if (observer.error) {
-                const exc = {
-                    runtimeException: true,
-                    type: 'asmail-delivery',
-                    msgNotFound: true
-                };
-                observer.error(exc);
+                observer.error((0, common_1.makeDeliveryException)({ id, msgNotFound: true }));
             }
             return () => { };
         }
@@ -149,6 +144,11 @@ class Delivery {
         if (!Array.isArray(recipients) || (recipients.length === 0)) {
             throw new Error(`Given invalid recipients: ${recipients} for message ${id}`);
         }
+        for (const recipient of recipients) {
+            if (this.r.correspondents.isAddressBlocked(recipient)) {
+                throw (0, common_1.makeDeliveryException)({ address: recipient, recipientBlocked: true });
+            }
+        }
         if (this.msgs.has(id)) {
             throw new Error(`Message with id ${id} has already been added for delivery`);
         }

package/build/core/asmail/delivery/msg.js

@@ -235,12 +235,7 @@ class Msg {
             return;
         }
         await filesProc.catch(() => { });
-        const exc = {
-            runtimeException: true,
-            type: 'asmail-delivery',
-            msgCancelled: true
-        };
-        this.progressPublisher.error(exc);
+        this.progressPublisher.error((0, common_1.makeDeliveryException)({ id: this.id, msgCancelled: true }));
     }
     /**
      * This starts sending a message to all recipients in parallel, and should be

package/build/core/asmail/delivery/per-recipient-wip.js

@@ -21,6 +21,7 @@ const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const sender_1 = require("../../../lib-client/asmail/sender");
 const synced_1 = require("../../../lib-common/processes/synced");
 const key_verification_1 = require("../key-verification");
+const common_1 = require("./common");
 const MSG_SIZE_FOR_STATE_RECORDING = 1024 * 1024;
 const EMPTY_BYTE_ARR = new Uint8Array(0);
 /**
@@ -209,14 +210,11 @@ class WIP {
         }
         const certs = await this.sender.getRecipientsInitPubKey();
         return (0, key_verification_1.checkAndExtractPKey)(this.sender.net, this.msg.r.midResolver, recipient, certs).catch(err => {
-            const exc = {
-                runtimeException: true,
-                type: 'asmail-delivery',
+            throw (0, common_1.makeDeliveryException)({
                 address: recipient,
                 recipientPubKeyFailsValidation: true,
                 cause: err
-            };
-            throw exc;
+            });
         });
     }
     /**

package/build/core/asmail/filtering.d.ts

@@ -0,0 +1,11 @@
+import { LogError } from "../../lib-client/logging/log-to-file";
+type WritableFS = web3n.files.WritableFS;
+type ASMailFilter = web3n.asmail.ASMailFilter;
+type FilteringRule = web3n.asmail.FilteringRule;
+export declare function makeAddressFilter(fs: WritableFS, logError: LogError, onRuleAddition: (r: FilteringRule) => Promise<void>): Promise<{
+    makeCAP: () => ASMailFilter;
+    isAddressBlocked: (address: string) => boolean;
+    close: () => void;
+}>;
+export type AddressFilter = Awaited<ReturnType<typeof makeAddressFilter>>;
+export {};

package/build/core/asmail/filtering.js

@@ -0,0 +1,219 @@
+"use strict";
+/*
+ Copyright (C) 2026 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAddressFilter = makeAddressFilter;
+const canonical_address_1 = require("../../lib-common/canonical-address");
+const single_file_1 = require("../../lib-common/dataset-sync/single-file");
+const json_utils_1 = require("../../lib-common/json-utils");
+const RULES_FNAME = 'rules.json';
+async function makeAddressFilter(fs, logError, onRuleAddition) {
+    const { file: rulesFile, changeProc } = await (0, single_file_1.initSyncedFile)(fs, RULES_FNAME, newFile => newFile.writeJSON([]));
+    let rules = await prepareRulesReadFromFile(await rulesFile.readJSON());
+    async function saveRulesAndTriggerSync() {
+        await changeProc.startOrChain(() => rulesFile.writeJSON(rules));
+        triggerUpload();
+    }
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(rulesFile, changeProc, onChangeFromOtherDevices, doOnConflict);
+    async function onChangeFromOtherDevices(newVersion) {
+        changeProc.startOrChain(async () => {
+            const { version, json } = await rulesFile.v.readJSON();
+            if (version === newVersion) {
+                rules = await prepareRulesReadFromFile(json);
+            }
+        });
+    }
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            const { remote, synced } = await rulesFile.v.sync.status(true);
+            const syncedRules = await prepareRulesReadFromFile((await rulesFile.v.readJSON({ remoteVersion: synced === null || synced === void 0 ? void 0 : synced.latest })).json);
+            const remoteRules = await prepareRulesReadFromFile((await rulesFile.v.readJSON({ remoteVersion: remote === null || remote === void 0 ? void 0 : remote.latest })).json);
+            const localRules = rules.concat();
+            const mergedRules = [];
+            while (remoteRules.length > 0) {
+                const r = remoteRules.shift();
+                const si = syncedRules.findIndex(sr => (0, json_utils_1.deepEqual)(sr, r));
+                const li = localRules.findIndex(lr => (0, json_utils_1.deepEqual)(lr, r));
+                if (si >= 0) {
+                    if (li >= 0) {
+                        // rule stays as is
+                        mergedRules.push(r);
+                    }
+                    else {
+                        // rule removed in local
+                    }
+                }
+                else {
+                    if (li >= 0) {
+                        // rule added in local and remote
+                        mergedRules.push(r);
+                    }
+                    else {
+                        // rule added in remote
+                        mergedRules.push(r);
+                    }
+                }
+                if (si > 0) {
+                    syncedRules.splice(si, 1);
+                }
+                if (li > 0) {
+                    localRules.splice(li, 1);
+                }
+            }
+            while (localRules.length > 0) {
+                const l = localRules.shift();
+                const si = syncedRules.findIndex(sr => (0, json_utils_1.deepEqual)(sr, l));
+                if (si >= 0) {
+                    // rule was removed in remote
+                }
+                else {
+                    // rule was added in local
+                    mergedRules.push(l);
+                }
+                if (si > 0) {
+                    syncedRules.splice(si, 1);
+                }
+            }
+            rules = mergedRules;
+            await rulesFile.writeJSON(rules);
+            await rulesFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+        });
+    }
+    async function prepareRulesReadFromFile(rulesFromFile) {
+        if (!Array.isArray(rulesFromFile)) {
+            await logError(`Expected array with rules`, `Reading of ASMail filter rules produced unexpected data`);
+            return [];
+        }
+        const rules = [];
+        const errors = [];
+        for (const r of rulesFromFile) {
+            try {
+                rules.push(prepareRuleFrom(r));
+            }
+            catch (err) {
+                errors.push(err);
+            }
+        }
+        if (errors.length > 0) {
+            await logError(errors[0], `Reading of ASMail filter rules produced produced ${errors.length} errors, the first one is here`);
+        }
+        return rules;
+    }
+    function groupRulesByDomains(rules) {
+        const m = new Map();
+        for (const rule of rules) {
+            const domain = rule.domain;
+            let domainRules = m.get(domain);
+            if (!domainRules) {
+                domainRules = [];
+                m.set(domain, domainRules);
+            }
+            domainRules.push(rule);
+        }
+        return m;
+    }
+    let rulesByDomain = groupRulesByDomains(rules);
+    async function addRule(ruleToAdd) {
+        const rule = prepareRuleFrom(ruleToAdd);
+        const ruleIndex = rules.push(rule) - 1;
+        rulesByDomain = groupRulesByDomains(rules);
+        await saveRulesAndTriggerSync();
+        await onRuleAddition(rule);
+        return { rule, ruleIndex };
+    }
+    async function removeRule(ruleIndex, rule) {
+        if ((ruleIndex < 0) || (ruleIndex >= rules.length) || !(0, json_utils_1.deepEqual)(rules[ruleIndex], rule)) {
+            return false;
+        }
+        rules.splice(ruleIndex, 1);
+        await saveRulesAndTriggerSync();
+        return true;
+    }
+    async function listRules() {
+        return rules;
+    }
+    function isAddressBlocked(address) {
+        const cAddr = (0, canonical_address_1.checkAndTransformAddress)(address);
+        if (!cAddr) {
+            return true;
+        }
+        const { uName, dName } = cAddrIntoParts(cAddr);
+        const domainRules = rulesByDomain.get(dName);
+        if (!domainRules) {
+            return false;
+        }
+        for (const rule of domainRules) {
+            if (rule.ruleType === 'block-domain') {
+                return true;
+            }
+            else if (rule.ruleType === 'block-address') {
+                if (uName == rule.username) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    function makeCAP() {
+        return {
+            addRule,
+            removeRule,
+            listRules
+        };
+    }
+    function close() {
+        stopFileWatching();
+    }
+    return {
+        makeCAP,
+        isAddressBlocked,
+        close
+    };
+}
+function cAddrIntoParts(cAddr) {
+    const atInd = cAddr.lastIndexOf('@');
+    if (atInd < 0) {
+        throw TypeError(`No @ in given canonical address: ${cAddr}`);
+    }
+    return {
+        uName: cAddr.substring(0, atInd),
+        dName: cAddr.substring(atInd + 1)
+    };
+}
+function prepareRuleFrom(r) {
+    switch (r.ruleType) {
+        case 'block-address': {
+            const cAddr = (0, canonical_address_1.toCanonicalAddress)(`${r.username}@${r.domain}`);
+            const { uName, dName } = cAddrIntoParts(cAddr);
+            return {
+                ruleType: 'block-address',
+                domain: dName, username: uName
+            };
+        }
+        case 'block-domain': {
+            const cAddr = (0, canonical_address_1.toCanonicalAddress)(`@${r.domain}`);
+            const { dName } = cAddrIntoParts(cAddr);
+            return {
+                ruleType: 'block-domain',
+                domain: dName
+            };
+        }
+        default:
+            throw TypeError(`Unknown rule type: ${r.ruleType}`);
+    }
+}
+Object.freeze(exports);

package/build/core/asmail/inbox/index.d.ts

@@ -62,6 +62,7 @@ export interface ResourcesForReceiving {
          */
         saveParamsForSendingTo: (address: string, params: SendingParams) => Promise<void>;
         midResolver: ServiceLocator;
+        isAddressBlocked(address: string): boolean;
     };
     logError: LogError;
 }

package/build/core/asmail/inbox/index.js

@@ -116,6 +116,9 @@ async function makeInboxOnServer(cachePath, syncedFS, localFS, r) {
             const decrOut = await r.correspondents.msgDecryptor(meta.extMeta, getMainObjHeader, getOpenedMsg, checkerOfMidKeyCerts(msgOnDisk.deliveryTS));
             if (decrOut) {
                 const { decrInfo, openedMsg } = decrOut;
+                if (r.correspondents.isAddressBlocked(decrInfo.correspondent)) {
+                    return false;
+                }
                 openedMsg.setMsgKeyRole(decrInfo.keyStatus);
                 // XXX we have never used this part of protocol, should it be removed at all from ASMail protocol?
                 checkServerAuthIfPresent(meta, decrInfo);

package/build/core/asmail/index.d.ts

@@ -23,6 +23,8 @@ export declare class ASMail {
     private delivery;
     private config;
     private sendingParams;
+    private getReportAddressForDomain;
+    private filter;
     constructor(cryptor: AsyncSBoxCryptor, random: AsyncRNG, makeNet: MakeNet, inboxPathForUser: InboxPathForUser, logger: Logger);
     init(address: string, getSigner: GetSigner, syncedFS: WritableFS, localFS: WritableFS, getStorages: StorageGetter, makeResolver: ServiceLocatorMaker, config: ConfigOfASMailServer, keyring: KeyringForASMail): Promise<void>;
     private setupSendingParams;
@@ -34,5 +36,6 @@ export declare class ASMail {
     suspendNetworkActivity(): void;
     resumeNetworkActivity(): void;
     get connectivityEvent$(): import("rxjs").Observable<import("./inbox/inbox-events").InboxConnectionStatus>;
+    private applyNewFilteringRuleToPeersInfo;
 }
 export {};

package/build/core/asmail/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2020 - 2022, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 2020 - 2022, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -22,9 +22,11 @@ const error_1 = require("../../lib-common/exceptions/error");
 const delivery_1 = require("./delivery");
 const sending_params_1 = require("./sending-params");
 const fs_sync_utils_1 = require("../../lib-client/fs-utils/fs-sync-utils");
+const filtering_1 = require("./filtering");
 const INBOX_DATA_FOLDER = 'inbox';
 const DELIVERY_DATA_FOLDER = 'delivery';
 const SEND_PARAMS_DATA_FOLDER = 'sending-params';
+const FILTERS_DATA_FOLDER = 'filtering';
 class ASMail {
     constructor(cryptor, random, makeNet, inboxPathForUser, logger) {
         this.cryptor = cryptor;
@@ -38,16 +40,20 @@ class ASMail {
         this.delivery = undefined;
         this.config = undefined;
         this.sendingParams = undefined;
+        this.getReportAddressForDomain = undefined;
+        this.filter = undefined;
         Object.seal(this);
     }
     async init(address, getSigner, syncedFS, localFS, getStorages, makeResolver, config, keyring) {
         try {
             this.address = address;
+            this.getReportAddressForDomain = makeResolver('report', this.logger.logError);
             // XXX this should be part of proper syncing logic
             // await getRemoteFolderChanges(syncedFS);
             this.config = config;
             this.keyring = keyring;
             await this.setupSendingParams(syncedFS);
+            this.filter = await (0, filtering_1.makeAddressFilter)(await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, FILTERS_DATA_FOLDER), this.logger.logError, this.applyNewFilteringRuleToPeersInfo.bind(this));
             await Promise.all([
                 this.setupInbox(syncedFS, localFS, getSigner, getStorages, makeResolver),
                 this.setupDelivery(localFS, getSigner, makeResolver)
@@ -78,7 +84,8 @@ class ASMail {
                 generateIntroKeysToSendMsg: this.keyring.generateIntroKeysToSendMsg,
                 getEstablishedKeysToSendMsg: this.keyring.getEstablishedKeysToSendMsg,
                 paramsForSendingTo: this.sendingParams.otherSides.get,
-                newParamsForSendingReplies: this.sendingParams.thisSide.getUpdated
+                newParamsForSendingReplies: this.sendingParams.thisSide.getUpdated,
+                isAddressBlocked: this.filter.isAddressBlocked
             },
             notifyMsgProgress: () => { throw new Error(`Method not set`); },
             makeNet: this.makeNet,
@@ -101,7 +108,8 @@ class ASMail {
                 msgDecryptor: this.keyring.decrypt,
                 markOwnSendingParamsAsUsed: this.sendingParams.thisSide.setAsUsed,
                 saveParamsForSendingTo: this.sendingParams.otherSides.set,
-                midResolver: makeResolver('mailerid', this.logger.logError)
+                midResolver: makeResolver('mailerid', this.logger.logError),
+                isAddressBlocked: this.filter.isAddressBlocked
             },
             makeNet: this.makeNet,
             logError: this.logger.logError
@@ -112,7 +120,9 @@ class ASMail {
             getUserId: async () => this.address,
             delivery: this.delivery.makeCAP(),
             inbox: this.inbox.makeCAP(),
-            config: this.config.makeCAP()
+            config: this.config.makeCAP(),
+            getReportAddressForDomain: this.getReportAddressForDomain,
+            filter: this.filter.makeCAP()
         };
         return Object.freeze(w);
     }
@@ -133,6 +143,7 @@ class ASMail {
         await this.delivery.close();
         await this.keyring.close();
         await this.sendingParams.close();
+        this.filter.close();
     }
     suspendNetworkActivity() {
         this.inbox.suspendNetworkActivity();
@@ -143,6 +154,23 @@ class ASMail {
     get connectivityEvent$() {
         return this.inbox.connectivityEvent$;
     }
+    async applyNewFilteringRuleToPeersInfo(r) {
+        switch (r.ruleType) {
+            case 'block-address': {
+                const { username, domain } = r;
+                const cAddr = `${username}@${domain}`;
+                await this.keyring.forgetCorrespondentAt(cAddr);
+                await this.sendingParams.forgetCorrespondentAt(cAddr);
+                break;
+            }
+            case 'block-domain': {
+                const { domain } = r;
+                await this.keyring.forgetCorrespondentAt(domain);
+                await this.sendingParams.forgetCorrespondentAt(domain);
+                break;
+            }
+        }
+    }
 }
 exports.ASMail = ASMail;
 Object.freeze(ASMail.prototype);

package/build/core/asmail/sending-params/index.d.ts

@@ -18,5 +18,7 @@ export interface SendingParamsHolder {
     thisSide: SendingParamsThisSide;
     otherSides: SendingParamsOtherSides;
     close: () => Promise<void>;
+    forgetCorrespondentAt(cAddr: string): Promise<void>;
+    forgetAllCorrespondentsAtDomain(domain: string): Promise<void>;
 }
 export declare function makeSendingParamsHolder(fs: WritableFS, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<SendingParamsHolder>;

package/build/core/asmail/sending-params/index.js

@@ -32,10 +32,20 @@ async function makeSendingParamsHolder(fs, anonInvitesOnServer, random) {
         await thisSide.close();
         await otherSides.close();
     }
+    async function forgetCorrespondentAt(cAddr) {
+        await otherSides.forgetCorrespondentAt(cAddr);
+        await thisSide.forgetCorrespondentAt(cAddr);
+    }
+    async function forgetAllCorrespondentsAtDomain(domain) {
+        await otherSides.forgetAllCorrespondentsAtDomain(domain);
+        await thisSide.forgetAllCorrespondentsAtDomain(domain);
+    }
     return {
         thisSide,
         otherSides,
-        close
+        close,
+        forgetCorrespondentAt,
+        forgetAllCorrespondentsAtDomain
     };
 }
 Object.freeze(exports);

package/build/core/asmail/sending-params/own-params.d.ts

@@ -4,5 +4,7 @@ type WritableFS = web3n.files.WritableFS;
 export type OwnSendingParams = Awaited<ReturnType<typeof makeOwnSendingParams>>;
 export declare function makeOwnSendingParams(fs: WritableFS, fileName: string, anonInvites: AnonymousInvites): Promise<SendingParamsHolder['thisSide'] & {
     close: () => Promise<void>;
+    forgetCorrespondentAt(cAddr: string): Promise<void>;
+    forgetAllCorrespondentsAtDomain(domain: string): Promise<void>;
 }>;
 export {};