@mamans2973/maman 0.0.0-stage → 1.0.0

package/lib/Types/Signal.d.ts

@@ -0,0 +1,57 @@
+import { proto } from '../../WAProto';
+type DecryptGroupSignalOpts = {
+    group: string;
+    authorJid: string;
+    msg: Uint8Array;
+};
+type ProcessSenderKeyDistributionMessageOpts = {
+    item: proto.Message.ISenderKeyDistributionMessage;
+    authorJid: string;
+};
+type DecryptSignalProtoOpts = {
+    jid: string;
+    type: 'pkmsg' | 'msg';
+    ciphertext: Uint8Array;
+};
+type EncryptMessageOpts = {
+    jid: string;
+    data: Uint8Array;
+};
+type EncryptGroupMessageOpts = {
+    group: string;
+    data: Uint8Array;
+    meId: string;
+};
+type PreKey = {
+    keyId: number;
+    publicKey: Uint8Array;
+};
+type SignedPreKey = PreKey & {
+    signature: Uint8Array;
+};
+type E2ESession = {
+    registrationId: number;
+    identityKey: Uint8Array;
+    signedPreKey: SignedPreKey;
+    preKey: PreKey;
+};
+type E2ESessionOpts = {
+    jid: string;
+    session: E2ESession;
+};
+export type SignalRepository = {
+    decryptGroupMessage(opts: DecryptGroupSignalOpts): Promise<Uint8Array>;
+    processSenderKeyDistributionMessage(opts: ProcessSenderKeyDistributionMessageOpts): Promise<void>;
+    decryptMessage(opts: DecryptSignalProtoOpts): Promise<Uint8Array>;
+    encryptMessage(opts: EncryptMessageOpts): Promise<{
+        type: 'pkmsg' | 'msg';
+        ciphertext: Uint8Array;
+    }>;
+    encryptGroupMessage(opts: EncryptGroupMessageOpts): Promise<{
+        senderKeyDistributionMessage: Uint8Array;
+        ciphertext: Uint8Array;
+    }>;
+    injectE2ESession(opts: E2ESessionOpts): Promise<void>;
+    jidToSignalProtocolAddress(jid: string): string;
+};
+export {};

package/lib/Types/Signal.js

@@ -0,0 +1 @@
+Object.defineProperty(exports,"__esModule",{value:!0});

package/lib/Types/Socket.d.ts

@@ -0,0 +1,121 @@
+import { AxiosRequestConfig } from 'axios';
+import type { Agent } from 'https';
+import type { URL } from 'url';
+import { proto } from '../../WAProto';
+import { ILogger } from '../Utils/logger';
+import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth';
+import { GroupMetadata } from './GroupMetadata';
+import { MediaConnInfo } from './Message';
+import { SignalRepository } from './Signal';
+export type WAVersion = [number, number, number];
+export type WABrowserDescription = [string, string, string];
+export type CacheStore = {
+    /** get a cached key and change the stats */
+    get<T>(key: string): T | undefined;
+    /** set a key in the cache */
+    set<T>(key: string, value: T): void;
+    /** delete a key from the cache */
+    del(key: string): void;
+    /** flush all data */
+    flushAll(): void;
+};
+export type PatchedMessageWithRecipientJID = proto.IMessage & {
+    recipientJid?: string;
+};
+export type SocketConfig = {
+    /** the WS url to connect to WA */
+    waWebSocketUrl: string | URL;
+    /** Fails the connection if the socket times out in this interval */
+    connectTimeoutMs: number;
+    /** Default timeout for queries, undefined for no timeout */
+    defaultQueryTimeoutMs: number | undefined;
+    /** ping-pong interval for WS connection */
+    keepAliveIntervalMs: number;
+    /** should baileys use the mobile api instead of the multi device api
+     * @deprecated This feature has been removed
+    */
+    mobile?: boolean;
+    /** proxy agent */
+    agent?: Agent;
+    /** logger */
+    logger: ILogger;
+    /** version to connect with */
+    version: WAVersion;
+    /** override browser config */
+    browser: WABrowserDescription;
+    /** agent used for fetch requests -- uploading/downloading media */
+    fetchAgent?: Agent;
+    /** should the QR be printed in the terminal
+    * @deprecated This feature has been removed
+    */
+    printQRInTerminal?: boolean;
+    /** should events be emitted for actions done by this socket connection */
+    emitOwnEvents: boolean;
+    /** custom upload hosts to upload media to */
+    customUploadHosts: MediaConnInfo['hosts'];
+    /** time to wait between sending new retry requests */
+    retryRequestDelayMs: number;
+    /** max retry count */
+    maxMsgRetryCount: number;
+    /** time to wait for the generation of the next QR in ms */
+    qrTimeout?: number;
+    /** provide an auth state object to maintain the auth state */
+    auth: AuthenticationState;
+    /** manage history processing with this control; by default will sync up everything */
+    shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean;
+    /** transaction capability options for SignalKeyStore */
+    transactionOpts: TransactionCapabilityOptions;
+    /** marks the client as online whenever the socket successfully connects */
+    markOnlineOnConnect: boolean;
+    /** alphanumeric country code (USA -> US) for the number used */
+    countryCode: string;
+    /** provide a cache to store media, so does not have to be re-uploaded */
+    mediaCache?: CacheStore;
+    /**
+     * map to store the retry counts for failed messages;
+     * used to determine whether to retry a message or not */
+    msgRetryCounterCache?: CacheStore;
+    /** provide a cache to store a user's device list */
+    userDevicesCache?: CacheStore;
+    /** cache to store call offers */
+    callOfferCache?: CacheStore;
+    /** cache to track placeholder resends */
+    placeholderResendCache?: CacheStore;
+    /** width for link preview images */
+    linkPreviewImageThumbnailWidth: number;
+    /** Should Baileys ask the phone for full history, will be received async */
+    syncFullHistory: boolean;
+    /** Should baileys fire init queries automatically, default true */
+    fireInitQueries: boolean;
+    /**
+     * generate a high quality link preview,
+     * entails uploading the jpegThumbnail to WA
+     * */
+    generateHighQualityLinkPreview: boolean;
+    /**
+     * Returns if a jid should be ignored,
+     * no event for that jid will be triggered.
+     * Messages from that jid will also not be decrypted
+     * */
+    shouldIgnoreJid: (jid: string) => boolean | undefined;
+    /**
+     * Optionally patch the message before sending out
+     * */
+    patchMessageBeforeSending: (msg: proto.IMessage, recipientJids?: string[]) => Promise<PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID> | PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID;
+    /** verify app state MACs */
+    appStateMacVerification: {
+        patch: boolean;
+        snapshot: boolean;
+    };
+    /** options for axios */
+    options: AxiosRequestConfig<{}>;
+    /**
+     * fetch a message from your store
+     * implement this so that messages failed to send
+     * (solves the "this message can take a while" issue) can be retried
+     * */
+    getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>;
+    /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
+    cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>;
+    makeSignalRepository: (auth: SignalAuthState) => SignalRepository;
+};

package/lib/Types/Socket.js

@@ -0,0 +1 @@
+Object.defineProperty(exports,"__esModule",{value:!0});

package/lib/Types/State.d.ts

@@ -0,0 +1,27 @@
+import { Contact } from './Contact';
+export type WAConnectionState = 'open' | 'connecting' | 'close';
+export type ConnectionState = {
+    /** connection is now open, connecting or closed */
+    connection: WAConnectionState;
+    /** the error that caused the connection to close */
+    lastDisconnect?: {
+        error: Error | undefined;
+        date: Date;
+    };
+    /** is this a new login */
+    isNewLogin?: boolean;
+    /** the current QR code */
+    qr?: string;
+    /** has the device received all pending notifications while it was offline */
+    receivedPendingNotifications?: boolean;
+    /** legacy connection options */
+    legacy?: {
+        phoneConnected: boolean;
+        user?: Contact;
+    };
+    /**
+     * if the client is shown as an active, online client.
+     * If this is false, the primary phone and other devices will receive notifs
+     * */
+    isOnline?: boolean;
+};

package/lib/Types/State.js

@@ -0,0 +1 @@
+Object.defineProperty(exports,"__esModule",{value:!0});

package/lib/Types/USync.d.ts

@@ -0,0 +1,25 @@
+import { BinaryNode } from '../WABinary';
+import { USyncUser } from '../WAUSync';
+/**
+ * Defines the interface for a USyncQuery protocol
+ */
+export interface USyncQueryProtocol {
+    /**
+     * The name of the protocol
+     */
+    name: string;
+    /**
+     * Defines what goes inside the query part of a USyncQuery
+     */
+    getQueryElement: () => BinaryNode;
+    /**
+     * Defines what goes inside the user part of a USyncQuery
+     */
+    getUserElement: (user: USyncUser) => BinaryNode | null;
+    /**
+     * Parse the result of the query
+     * @param data Data from the result
+     * @returns Whatever the protocol is supposed to return
+     */
+    parser: (data: BinaryNode) => unknown;
+}

package/lib/Types/USync.js

@@ -0,0 +1 @@
+Object.defineProperty(exports,"__esModule",{value:!0});

package/lib/Types/index.d.ts

@@ -0,0 +1,63 @@
+export * from './Auth';
+export * from './GroupMetadata';
+export * from './Chat';
+export * from './Contact';
+export * from './State';
+export * from './Message';
+export * from './Socket';
+export * from './Events';
+export * from './Product';
+export * from './Call';
+export * from './Signal';
+import { AuthenticationState } from './Auth';
+import { SocketConfig } from './Socket';
+export type UserFacingSocketConfig = Partial<SocketConfig> & {
+    auth: AuthenticationState;
+};
+export type BrowsersMap = {
+    ubuntu(browser: string): [string, string, string];
+    macOS(browser: string): [string, string, string];
+    baileys(browser: string): [string, string, string];
+    windows(browser: string): [string, string, string];
+    appropriate(browser: string): [string, string, string];
+};
+export declare enum DisconnectReason {
+    connectionClosed = 428,
+    connectionLost = 408,
+    connectionReplaced = 440,
+    timedOut = 408,
+    loggedOut = 401,
+    badSession = 500,
+    restartRequired = 515,
+    multideviceMismatch = 411,
+    forbidden = 403,
+    unavailableService = 503
+}
+export type WAInitResponse = {
+    ref: string;
+    ttl: number;
+    status: 200;
+};
+export type WABusinessHoursConfig = {
+    day_of_week: string;
+    mode: string;
+    open_time?: number;
+    close_time?: number;
+};
+export type WABusinessProfile = {
+    description: string;
+    email: string | undefined;
+    business_hours: {
+        timezone?: string;
+        config?: WABusinessHoursConfig[];
+        business_config?: WABusinessHoursConfig[];
+    };
+    website: string[];
+    category?: string;
+    wid?: string;
+    address?: string;
+};
+export type CurveKeyPair = {
+    private: Uint8Array;
+    public: Uint8Array;
+};

package/lib/Types/index.js

@@ -0,0 +1,4 @@
+var __createBinding=this&&this.__createBinding||(Object.create?function(a,c,b,d){void 0===d&&(d=b);var e=Object.getOwnPropertyDescriptor(c,b);if(!e||("get"in e?!c.__esModule:e.writable||e.configurable))e={enumerable:!0,get:function(){return c[b]}};Object.defineProperty(a,d,e)}:function(a,c,b,d){void 0===d&&(d=b);a[d]=c[b]}),__exportStar=this&&this.__exportStar||function(a,c){for(var b in a)"default"===b||Object.prototype.hasOwnProperty.call(c,b)||__createBinding(c,a,b)};
+Object.defineProperty(exports,"__esModule",{value:!0});exports.DisconnectReason=void 0;__exportStar(require("./Auth"),exports);__exportStar(require("./GroupMetadata"),exports);__exportStar(require("./Chat"),exports);__exportStar(require("./Contact"),exports);__exportStar(require("./State"),exports);__exportStar(require("./Message"),exports);__exportStar(require("./Socket"),exports);__exportStar(require("./Events"),exports);__exportStar(require("./Product"),exports);
+__exportStar(require("./Call"),exports);__exportStar(require("./Signal"),exports);var DisconnectReason;
+(function(a){a[a.connectionClosed=428]="connectionClosed";a[a.connectionLost=408]="connectionLost";a[a.connectionReplaced=440]="connectionReplaced";a[a.timedOut=408]="timedOut";a[a.loggedOut=401]="loggedOut";a[a.badSession=500]="badSession";a[a.restartRequired=515]="restartRequired";a[a.multideviceMismatch=411]="multideviceMismatch";a[a.forbidden=403]="forbidden";a[a.unavailableService=503]="unavailableService"})(DisconnectReason||(exports.DisconnectReason=DisconnectReason={}));

package/lib/Utils/auth-utils.d.ts

@@ -0,0 +1,18 @@
+import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types';
+import { ILogger } from './logger';
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger?: ILogger, _cache?: CacheStore): SignalKeyStore;
+/**
+ * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
+ * this allows batch read & write operations & improves the performance of the lib
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export declare const addTransactionCapability: (state: SignalKeyStore, logger: ILogger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction;
+export declare const initAuthCreds: () => AuthenticationCreds;

package/lib/Utils/auth-utils.js

@@ -0,0 +1,8 @@
+var __importDefault=this&&this.__importDefault||function(d){return d&&d.__esModule?d:{"default":d}};Object.defineProperty(exports,"__esModule",{value:!0});exports.initAuthCreds=exports.addTransactionCapability=void 0;exports.makeCacheableSignalKeyStore=makeCacheableSignalKeyStore;const node_cache_1=__importDefault(require("@cacheable/node-cache")),crypto_1=require("crypto"),Defaults_1=require("../Defaults"),crypto_2=require("./crypto"),generics_1=require("./generics");
+function makeCacheableSignalKeyStore(d,h,n){const k=n||new node_cache_1.default({stdTTL:Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,useClones:!1,deleteOnExpire:!0});return{async get(f,e){const g={};var b=[];for(var a of e)e=k.get(`${f}.${a}`),"undefined"!==typeof e?g[a]=e:b.push(a);if(b.length){null===h||void 0===h||h.trace({items:b.length},"loading from store");a=await d.get(f,b);for(const c of b)if(b=a[c])g[c]=b,k.set(`${f}.${c}`,b)}return g},async set(f){let e=0;for(const g in f)for(const b in f[g])k.set(`${g}.${b}`,
+f[g][b]),e+=1;null===h||void 0===h||h.trace({keys:e},"updated cache");await d.set(f)},async clear(){var f;k.flushAll();await (null===(f=d.clear)||void 0===f?void 0:f.call(d))}}}
+const addTransactionCapability=(d,h,{maxCommitRetries:n,delayBetweenTriesMs:k})=>{let f=0,e={},g={},b=0;return{get:async(a,c)=>{if(0<b){const q=e[a];var l=q?c.filter(m=>"undefined"===typeof q[m]):c;l.length&&(f+=1,l=await d.get(a,l),e[a]||(e[a]={}),Object.assign(e[a],l));return c.reduce((m,r)=>{var p;const t=null===(p=e[a])||void 0===p?void 0:p[r];t&&(m[r]=t);return m},{})}return d.get(a,c)},set:a=>{if(0<b){h.trace({types:Object.keys(a)},"caching in transaction");for(const c in a)e[c]=e[c]||{},Object.assign(e[c],
+a[c]),g[c]=g[c]||{},Object.assign(g[c],a[c])}else return d.set(a)},isInTransaction:function(){return 0<b},async transaction(a){let c;b+=1;1===b&&h.trace("entering transaction");try{if(c=await a(),1===b)if(Object.keys(g).length)for(h.trace("committing transaction"),a=n;a;){--a;try{await d.set(g);h.trace({dbQueriesInTransaction:f},"committed transaction");break}catch(l){h.warn(`failed to commit ${Object.keys(g).length} mutations, tries left=${a}`),await (0,generics_1.delay)(k)}}else h.trace("no mutations in transaction")}finally{--b,
+0===b&&(e={},g={},f=0)}return c}}};exports.addTransactionCapability=addTransactionCapability;
+const initAuthCreds=()=>{const d=crypto_2.Curve.generateKeyPair();return{noiseKey:crypto_2.Curve.generateKeyPair(),pairingEphemeralKeyPair:crypto_2.Curve.generateKeyPair(),signedIdentityKey:d,signedPreKey:(0,crypto_2.signedKeyPair)(d,1),registrationId:(0,generics_1.generateRegistrationId)(),advSecretKey:(0,crypto_1.randomBytes)(32).toString("base64"),processedHistoryMessages:[],nextPreKeyId:1,firstUnuploadedPreKeyId:1,accountSyncCounter:0,accountSettings:{unarchiveChats:!1},registered:!1,pairingCode:void 0,
+lastPropHash:void 0,routingInfo:void 0}};exports.initAuthCreds=initAuthCreds;

package/lib/Utils/baileys-event-stream.d.ts

@@ -0,0 +1,16 @@
+import type { BaileysEventEmitter } from '../Types';
+/**
+ * Captures events from a baileys event emitter & stores them in a file
+ * @param ev The event emitter to read events from
+ * @param filename File to save to
+ */
+export declare const captureEventStream: (ev: BaileysEventEmitter, filename: string) => void;
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+export declare const readAndEmitEventStream: (filename: string, delayIntervalMs?: number) => {
+    ev: BaileysEventEmitter;
+    task: Promise<void>;
+};

package/lib/Utils/baileys-event-stream.js

@@ -0,0 +1,3 @@
+var __importDefault=this&&this.__importDefault||function(a){return a&&a.__esModule?a:{"default":a}};Object.defineProperty(exports,"__esModule",{value:!0});exports.readAndEmitEventStream=exports.captureEventStream=void 0;
+const events_1=__importDefault(require("events")),fs_1=require("fs"),promises_1=require("fs/promises"),readline_1=require("readline"),generics_1=require("./generics"),make_mutex_1=require("./make-mutex"),captureEventStream=(a,c)=>{const d=a.emit,e=(0,make_mutex_1.makeMutex)();a.emit=function(...b){const f=JSON.stringify({timestamp:Date.now(),event:b[0],data:b[1]})+"\n";b=d.apply(a,b);e.mutex(async()=>{await (0,promises_1.writeFile)(c,f,{flag:"a"})});return b}};exports.captureEventStream=captureEventStream;
+const readAndEmitEventStream=(a,c=0)=>{const d=new events_1.default;return{ev:d,task:(async()=>{const e=(0,fs_1.createReadStream)(a),b=(0,readline_1.createInterface)({input:e,crlfDelay:Infinity});for await(const f of b)if(f){const {event:g,data:h}=JSON.parse(f);d.emit(g,h);c&&await (0,generics_1.delay)(c)}e.close()})()}};exports.readAndEmitEventStream=readAndEmitEventStream;

package/lib/Utils/business.d.ts

@@ -0,0 +1,22 @@
+import { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate, WAMediaUpload, WAMediaUploadFunction } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const parseCatalogNode: (node: BinaryNode) => {
+    products: Product[];
+    nextPageCursor: string | undefined;
+};
+export declare const parseCollectionsNode: (node: BinaryNode) => {
+    collections: CatalogCollection[];
+};
+export declare const parseOrderDetailsNode: (node: BinaryNode) => OrderDetails;
+export declare const toProductNode: (productId: string | undefined, product: ProductCreate | ProductUpdate) => BinaryNode;
+export declare const parseProductNode: (productNode: BinaryNode) => Product;
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export declare function uploadingNecessaryImagesOfProduct<T extends ProductUpdate | ProductCreate>(product: T, waUploadToServer: WAMediaUploadFunction, timeoutMs?: number): Promise<T>;
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export declare const uploadingNecessaryImages: (images: WAMediaUpload[], waUploadToServer: WAMediaUploadFunction, timeoutMs?: number) => Promise<{
+    url: string;
+}[]>;

package/lib/Utils/business.js

@@ -0,0 +1,14 @@
+Object.defineProperty(exports,"__esModule",{value:!0});exports.uploadingNecessaryImages=exports.parseProductNode=exports.toProductNode=exports.parseOrderDetailsNode=exports.parseCollectionsNode=exports.parseCatalogNode=void 0;exports.uploadingNecessaryImagesOfProduct=uploadingNecessaryImagesOfProduct;
+const boom_1=require("@hapi/boom"),crypto_1=require("crypto"),fs_1=require("fs"),os_1=require("os"),path_1=require("path"),WABinary_1=require("../WABinary"),generics_1=require("./generics"),messages_media_1=require("./messages-media"),parseCatalogNode=a=>{var b=(0,WABinary_1.getBinaryNodeChild)(a,"product_catalog");a=(0,WABinary_1.getBinaryNodeChildren)(b,"product").map(exports.parseProductNode);b=(0,WABinary_1.getBinaryNodeChild)(b,"paging");return{products:a,nextPageCursor:b?(0,WABinary_1.getBinaryNodeChildString)(b,
+"after"):void 0}};exports.parseCatalogNode=parseCatalogNode;const parseCollectionsNode=a=>{a=(0,WABinary_1.getBinaryNodeChild)(a,"collections");return{collections:(0,WABinary_1.getBinaryNodeChildren)(a,"collection").map(b=>{const d=(0,WABinary_1.getBinaryNodeChildString)(b,"id"),c=(0,WABinary_1.getBinaryNodeChildString)(b,"name"),e=(0,WABinary_1.getBinaryNodeChildren)(b,"product").map(exports.parseProductNode);return{id:d,name:c,products:e,status:parseStatusInfo(b)}})}};
+exports.parseCollectionsNode=parseCollectionsNode;
+const parseOrderDetailsNode=a=>{var b=(0,WABinary_1.getBinaryNodeChild)(a,"order");a=(0,WABinary_1.getBinaryNodeChildren)(b,"product").map(d=>{const c=(0,WABinary_1.getBinaryNodeChild)(d,"image");return{id:(0,WABinary_1.getBinaryNodeChildString)(d,"id"),name:(0,WABinary_1.getBinaryNodeChildString)(d,"name"),imageUrl:(0,WABinary_1.getBinaryNodeChildString)(c,"url"),price:+(0,WABinary_1.getBinaryNodeChildString)(d,"price"),currency:(0,WABinary_1.getBinaryNodeChildString)(d,"currency"),quantity:+(0,WABinary_1.getBinaryNodeChildString)(d,
+"quantity")}});b=(0,WABinary_1.getBinaryNodeChild)(b,"price");return{price:{total:+(0,WABinary_1.getBinaryNodeChildString)(b,"total"),currency:(0,WABinary_1.getBinaryNodeChildString)(b,"currency")},products:a}};exports.parseOrderDetailsNode=parseOrderDetailsNode;
+const toProductNode=(a,b)=>{const d={},c=[];"undefined"!==typeof a&&c.push({tag:"id",attrs:{},content:Buffer.from(a)});"undefined"!==typeof b.name&&c.push({tag:"name",attrs:{},content:Buffer.from(b.name)});"undefined"!==typeof b.description&&c.push({tag:"description",attrs:{},content:Buffer.from(b.description)});"undefined"!==typeof b.retailerId&&c.push({tag:"retailer_id",attrs:{},content:Buffer.from(b.retailerId)});b.images.length&&c.push({tag:"media",attrs:{},content:b.images.map(e=>{if(!("url"in
+e))throw new boom_1.Boom("Expected img for product to already be uploaded",{statusCode:400});return{tag:"image",attrs:{},content:[{tag:"url",attrs:{},content:Buffer.from(e.url.toString())}]}})});"undefined"!==typeof b.price&&c.push({tag:"price",attrs:{},content:Buffer.from(b.price.toString())});"undefined"!==typeof b.currency&&c.push({tag:"currency",attrs:{},content:Buffer.from(b.currency)});"originCountryCode"in b&&("undefined"===typeof b.originCountryCode?d.compliance_category="COUNTRY_ORIGIN_EXEMPT":
+c.push({tag:"compliance_info",attrs:{},content:[{tag:"country_code_origin",attrs:{},content:Buffer.from(b.originCountryCode)}]}));"undefined"!==typeof b.isHidden&&(d.is_hidden=b.isHidden.toString());return{tag:"product",attrs:d,content:c}};exports.toProductNode=toProductNode;
+const parseProductNode=a=>{const b="true"===a.attrs.is_hidden,d=(0,WABinary_1.getBinaryNodeChildString)(a,"id"),c=(0,WABinary_1.getBinaryNodeChild)(a,"media"),e=(0,WABinary_1.getBinaryNodeChild)(a,"status_info");return{id:d,imageUrls:parseImageUrls(c),reviewStatus:{whatsapp:(0,WABinary_1.getBinaryNodeChildString)(e,"status")},availability:"in stock",name:(0,WABinary_1.getBinaryNodeChildString)(a,"name"),retailerId:(0,WABinary_1.getBinaryNodeChildString)(a,"retailer_id"),url:(0,WABinary_1.getBinaryNodeChildString)(a,
+"url"),description:(0,WABinary_1.getBinaryNodeChildString)(a,"description"),price:+(0,WABinary_1.getBinaryNodeChildString)(a,"price"),currency:(0,WABinary_1.getBinaryNodeChildString)(a,"currency"),isHidden:b}};exports.parseProductNode=parseProductNode;async function uploadingNecessaryImagesOfProduct(a,b,d=3E4){return a={...a,images:a.images?await (0,exports.uploadingNecessaryImages)(a.images,b,d):a.images}}
+const uploadingNecessaryImages=async(a,b,d=3E4)=>await Promise.all(a.map(async c=>{if("url"in c){var e=c.url.toString();if(e.includes(".whatsapp.net"))return{url:e}}({stream:e}=await (0,messages_media_1.getStream)(c));const g=(0,crypto_1.createHash)("sha256");c=(0,path_1.join)((0,os_1.tmpdir)(),"img"+(0,generics_1.generateMessageIDV2)());const h=(0,fs_1.createWriteStream)(c);for await(var f of e)g.update(f),h.write(f);f=g.digest("base64");({directPath:f}=await b(c,{mediaType:"product-catalog-image",
+fileEncSha256B64:f,timeoutMs:d}));await fs_1.promises.unlink(c).catch(k=>console.log("Error deleting temp file ",k));return{url:(0,messages_media_1.getUrlFromDirectPath)(f)}}));exports.uploadingNecessaryImages=uploadingNecessaryImages;
+const parseImageUrls=a=>{a=(0,WABinary_1.getBinaryNodeChild)(a,"image");return{requested:(0,WABinary_1.getBinaryNodeChildString)(a,"request_image_url"),original:(0,WABinary_1.getBinaryNodeChildString)(a,"original_image_url")}},parseStatusInfo=a=>{a=(0,WABinary_1.getBinaryNodeChild)(a,"status_info");return{status:(0,WABinary_1.getBinaryNodeChildString)(a,"status"),canAppeal:"true"===(0,WABinary_1.getBinaryNodeChildString)(a,"can_appeal")}};

package/lib/Utils/chat-utils.d.ts

@@ -0,0 +1,70 @@
+import { AxiosRequestConfig } from 'axios';
+import { proto } from '../../WAProto';
+import { BaileysEventEmitter, ChatModification, ChatMutation, Contact, InitialAppStateSyncOptions, LTHashState, WAPatchCreate, WAPatchName } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { ILogger } from './logger';
+type FetchAppStateSyncKey = (keyId: string) => Promise<proto.Message.IAppStateSyncKeyData | null | undefined>;
+export type ChatMutationMap = {
+    [index: string]: ChatMutation;
+};
+export declare const newLTHashState: () => LTHashState;
+export declare const encodeSyncdPatch: ({ type, index, syncAction, apiVersion, operation }: WAPatchCreate, myAppStateKeyId: string, state: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey) => Promise<{
+    patch: proto.ISyncdPatch;
+    state: LTHashState;
+}>;
+export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation | proto.ISyncdRecord)[], initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
+    hash: Buffer<any>;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+}>;
+export declare const decodeSyncdPatch: (msg: proto.ISyncdPatch, name: WAPatchName, initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
+    hash: Buffer<any>;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+}>;
+export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosRequestConfig<{}>) => Promise<{
+    critical_block: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+    critical_unblock_low: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+    regular_high: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+    regular_low: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+    regular: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+}>;
+export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<{}>) => Promise<Buffer<ArrayBuffer>>;
+export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<{}>) => Promise<proto.SyncdMutations>;
+export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean) => Promise<{
+    state: LTHashState;
+    mutationMap: ChatMutationMap;
+}>;
+export declare const decodePatches: (name: WAPatchName, syncds: proto.ISyncdPatch[], initial: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, options: AxiosRequestConfig<{}>, minimumVersionNumber?: number, logger?: ILogger, validateMacs?: boolean) => Promise<{
+    state: LTHashState;
+    mutationMap: ChatMutationMap;
+}>;
+export declare const chatModificationToAppPatch: (mod: ChatModification, jid: string) => WAPatchCreate;
+export declare const processSyncAction: (syncAction: ChatMutation, ev: BaileysEventEmitter, me: Contact, initialSyncOpts?: InitialAppStateSyncOptions, logger?: ILogger) => void;
+export {};

package/lib/Utils/chat-utils.js

@@ -0,0 +1,36 @@
+Object.defineProperty(exports,"__esModule",{value:!0});exports.processSyncAction=exports.chatModificationToAppPatch=exports.decodePatches=exports.decodeSyncdSnapshot=exports.downloadExternalPatch=exports.downloadExternalBlob=exports.extractSyncdPatches=exports.decodeSyncdPatch=exports.decodeSyncdMutations=exports.encodeSyncdPatch=exports.newLTHashState=void 0;
+const boom_1=require("@hapi/boom"),WAProto_1=require("../../WAProto"),LabelAssociation_1=require("../Types/LabelAssociation"),WABinary_1=require("../WABinary"),crypto_1=require("./crypto"),generics_1=require("./generics"),lt_hash_1=require("./lt-hash"),messages_media_1=require("./messages-media"),mutationKeys=async a=>{a=await (0,crypto_1.hkdf)(a,160,{info:"WhatsApp Mutation Keys"});return{indexKey:a.slice(0,32),valueEncryptionKey:a.slice(32,64),valueMacKey:a.slice(64,96),snapshotMacKey:a.slice(96,
+128),patchMacKey:a.slice(128,160)}},generateMac=(a,b,c,g)=>{let f;switch(a){case WAProto_1.proto.SyncdMutation.SyncdOperation.SET:f=1;break;case WAProto_1.proto.SyncdMutation.SyncdOperation.REMOVE:f=2}a=Buffer.from([f]);c=Buffer.concat([a,Buffer.from(c,"base64")]);a=Buffer.alloc(8);a.set([c.length],a.length-1);b=Buffer.concat([c,b,a]);return(0,crypto_1.hmacSign)(b,g,"sha512").slice(0,32)},to64BitNetworkOrder=a=>{const b=Buffer.alloc(8);b.writeUint32BE(a,4);return b},makeLtHashGenerator=({indexValueMap:a,
+hash:b})=>{a={...a};const c=[],g=[];return{mix:({indexMac:f,valueMac:h,operation:d})=>{const k=Buffer.from(f).toString("base64"),l=a[k];if(d===WAProto_1.proto.SyncdMutation.SyncdOperation.REMOVE){if(!l)throw new boom_1.Boom("tried remove, but no previous op",{data:{indexMac:f,valueMac:h}});delete a[k]}else c.push((new Uint8Array(h)).buffer),a[k]={valueMac:h};l&&g.push((new Uint8Array(l.valueMac)).buffer)},finish:async()=>{var f=(new Uint8Array(b)).buffer;f=await lt_hash_1.LT_HASH_ANTI_TAMPERING.subtractThenAdd(f,
+c,g);return{hash:Buffer.from(f),indexValueMap:a}}}},generateSnapshotMac=(a,b,c,g)=>{a=Buffer.concat([a,to64BitNetworkOrder(b),Buffer.from(c,"utf-8")]);return(0,crypto_1.hmacSign)(a,g,"sha256")},generatePatchMac=(a,b,c,g,f)=>{a=Buffer.concat([a,...b,to64BitNetworkOrder(c),Buffer.from(g,"utf-8")]);return(0,crypto_1.hmacSign)(a,f)},newLTHashState=()=>({version:0,hash:Buffer.alloc(128),indexValueMap:{}});exports.newLTHashState=newLTHashState;
+const encodeSyncdPatch=async({type:a,index:b,syncAction:c,apiVersion:g,operation:f},h,d,k)=>{k=h?await k(h):void 0;if(!k)throw new boom_1.Boom(`myAppStateKey ("${h}") not present`,{statusCode:404});h=Buffer.from(h,"base64");d={...d,indexValueMap:{...d.indexValueMap}};b=Buffer.from(JSON.stringify(b));c=WAProto_1.proto.SyncActionData.fromObject({index:b,value:c,padding:new Uint8Array(0),version:g});g=WAProto_1.proto.SyncActionData.encode(c).finish();c=await mutationKeys(k.keyData);g=(0,crypto_1.aesEncrypt)(g,
+c.valueEncryptionKey);k=generateMac(f,g,h,c.valueMacKey);b=(0,crypto_1.hmacSign)(b,c.indexKey);var l=makeLtHashGenerator(d);l.mix({indexMac:b,valueMac:k,operation:f});Object.assign(d,await l.finish());d.version+=1;l=generateSnapshotMac(d.hash,d.version,a,c.snapshotMacKey);a={patchMac:generatePatchMac(l,[k],d.version,a,c.patchMacKey),snapshotMac:l,keyId:{id:h},mutations:[{operation:f,record:{index:{blob:b},value:{blob:Buffer.concat([g,k])},keyId:{id:h}}}]};f=b.toString("base64");d.indexValueMap[f]=
+{valueMac:k};return{patch:a,state:d}};exports.encodeSyncdPatch=encodeSyncdPatch;
+const decodeSyncdMutations=async(a,b,c,g,f)=>{async function h(n){n=Buffer.from(n).toString("base64");const p=await c(n);if(!p)throw new boom_1.Boom(`failed to find key "${n}" to decode mutation`,{statusCode:404,data:{msgMutations:a}});return mutationKeys(p.keyData)}b=makeLtHashGenerator(b);for(const n of a){const p="operation"in n?n.operation:WAProto_1.proto.SyncdMutation.SyncdOperation.SET,m="record"in n&&n.record?n.record:n;var d=await h(m.keyId.id),k=Buffer.from(m.value.blob),l=k.slice(0,-32);
+k=k.slice(-32);if(f){const e=generateMac(p,l,m.keyId.id,d.valueMacKey);if(0!==Buffer.compare(e,k))throw new boom_1.Boom("HMAC content verification failed");}l=(0,crypto_1.aesDecrypt)(l,d.valueEncryptionKey);l=WAProto_1.proto.SyncActionData.decode(l);if(f&&(d=(0,crypto_1.hmacSign)(l.index,d.indexKey),0!==Buffer.compare(d,m.index.blob)))throw new boom_1.Boom("HMAC index verification failed");d=Buffer.from(l.index).toString();g({syncAction:l,index:JSON.parse(d)});b.mix({indexMac:m.index.blob,valueMac:k,
+operation:p})}return await b.finish()};exports.decodeSyncdMutations=decodeSyncdMutations;
+const decodeSyncdPatch=async(a,b,c,g,f,h)=>{if(h){var d=Buffer.from(a.keyId.id).toString("base64"),k=await g(d);if(!k)throw new boom_1.Boom(`failed to find key "${d}" to decode patch`,{statusCode:404,data:{msg:a}});d=await mutationKeys(k.keyData);k=a.mutations.map(l=>l.record.value.blob.slice(-32));b=generatePatchMac(a.snapshotMac,k,(0,generics_1.toNumber)(a.version.version),b,d.patchMacKey);if(0!==Buffer.compare(b,a.patchMac))throw new boom_1.Boom("Invalid patch mac");}return await (0,exports.decodeSyncdMutations)(a.mutations,
+c,g,f,h)};exports.decodeSyncdPatch=decodeSyncdPatch;
+const extractSyncdPatches=async(a,b)=>{a=(0,WABinary_1.getBinaryNodeChild)(a,"sync");a=(0,WABinary_1.getBinaryNodeChildren)(a,"collection");const c={};await Promise.all(a.map(async g=>{var f=(0,WABinary_1.getBinaryNodeChild)(g,"patches"),h=(0,WABinary_1.getBinaryNodeChildren)(f||g,"patch");const d=(0,WABinary_1.getBinaryNodeChild)(g,"snapshot");f=[];const k=g.attrs.name,l="true"===g.attrs.has_more_patches;var n=void 0;d&&d.content&&(Buffer.isBuffer(d)||(d.content=Buffer.from(Object.values(d.content))),
+n=WAProto_1.proto.ExternalBlobReference.decode(d.content),n=await (0,exports.downloadExternalBlob)(n,b),n=WAProto_1.proto.SyncdSnapshot.decode(n));for(let {content:p}of h)p&&(Buffer.isBuffer(p)||(p=Buffer.from(Object.values(p))),h=WAProto_1.proto.SyncdPatch.decode(p),h.version||(h.version={version:+g.attrs.version+1}),f.push(h));c[k]={patches:f,hasMorePatches:l,snapshot:n}}));return c};exports.extractSyncdPatches=extractSyncdPatches;
+const downloadExternalBlob=async(a,b)=>{a=await (0,messages_media_1.downloadContentFromMessage)(a,"md-app-state",{options:b});b=[];for await(const c of a)b.push(c);return Buffer.concat(b)};exports.downloadExternalBlob=downloadExternalBlob;const downloadExternalPatch=async(a,b)=>{a=await (0,exports.downloadExternalBlob)(a,b);return WAProto_1.proto.SyncdMutations.decode(a)};exports.downloadExternalPatch=downloadExternalPatch;
+const decodeSyncdSnapshot=async(a,b,c,g,f=!0)=>{const h=(0,exports.newLTHashState)();h.version=(0,generics_1.toNumber)(b.version.version);const d={},{hash:k,indexValueMap:l}=await (0,exports.decodeSyncdMutations)(b.records,h,c,"undefined"===typeof g||h.version>g?n=>{var p;const m=null===(p=n.syncAction.index)||void 0===p?void 0:p.toString();d[m]=n}:()=>{},f);h.hash=k;h.indexValueMap=l;if(f){g=Buffer.from(b.keyId.id).toString("base64");c=await c(g);if(!c)throw new boom_1.Boom(`failed to find key "${g}" to decode mutation`);
+c=await mutationKeys(c.keyData);c=generateSnapshotMac(h.hash,h.version,a,c.snapshotMacKey);if(0!==Buffer.compare(b.mac,c))throw new boom_1.Boom(`failed to verify LTHash at ${h.version} of ${a} from snapshot`);}return{state:h,mutationMap:d}};exports.decodeSyncdSnapshot=decodeSyncdSnapshot;
+const decodePatches=async(a,b,c,g,f,h,d,k=!0)=>{var l;c={...c,indexValueMap:{...c.indexValueMap}};const n={};for(const p of b){const {version:m,keyId:e,snapshotMac:r}=p;p.externalMutations&&(null===d||void 0===d||d.trace({name:a,version:m},"downloading external patch"),b=await (0,exports.downloadExternalPatch)(p.externalMutations,f),null===d||void 0===d||d.debug({name:a,version:m,mutations:b.mutations.length},"downloaded external patch"),null===(l=p.mutations)||void 0===l||l.push(...b.mutations));
+b=(0,generics_1.toNumber)(m.version);c.version=b;b=await (0,exports.decodeSyncdPatch)(p,a,c,g,"undefined"===typeof h||b>h?q=>{var v;const w=null===(v=q.syncAction.index)||void 0===v?void 0:v.toString();n[w]=q}:()=>{},!0);c.hash=b.hash;c.indexValueMap=b.indexValueMap;if(k){b=Buffer.from(e.id).toString("base64");const q=await g(b);if(!q)throw new boom_1.Boom(`failed to find key "${b}" to decode mutation`);b=await mutationKeys(q.keyData);b=generateSnapshotMac(c.hash,c.version,a,b.snapshotMacKey);if(0!==
+Buffer.compare(r,b))throw new boom_1.Boom(`failed to verify LTHash at ${c.version} of ${a}`);}p.mutations=[]}return{state:c,mutationMap:n}};exports.decodePatches=decodePatches;
+const chatModificationToAppPatch=(a,b)=>{const c=WAProto_1.proto.SyncdMutation.SyncdOperation;var g=f=>{if(Array.isArray(f)){const h=f[f.length-1];f={lastMessageTimestamp:null===h||void 0===h?void 0:h.messageTimestamp,messages:(null===f||void 0===f?0:f.length)?f.map(d=>{var k,l;if(!((null===(k=d.key)||void 0===k?0:k.id)&&(null===(l=d.key)||void 0===l?0:l.remoteJid)))throw new boom_1.Boom("Incomplete key",{statusCode:400,data:d});if((0,WABinary_1.isJidGroup)(d.key.remoteJid)&&!d.key.fromMe&&!d.key.participant)throw new boom_1.Boom("Expected not from me message to have participant",
+{statusCode:400,data:d});if(!d.messageTimestamp||!(0,generics_1.toNumber)(d.messageTimestamp))throw new boom_1.Boom("Missing timestamp in last message list",{statusCode:400,data:d});d.key.participant&&(d.key.participant=(0,WABinary_1.jidNormalizedUser)(d.key.participant));return d}):void 0}}return f};if("mute"in a)a={syncAction:{muteAction:{muted:!!a.mute,muteEndTimestamp:a.mute||void 0}},index:["mute",b],type:"regular_high",apiVersion:2,operation:c.SET};else if("archive"in a)a={syncAction:{archiveChatAction:{archived:!!a.archive,
+messageRange:g(a.lastMessages)}},index:["archive",b],type:"regular_low",apiVersion:3,operation:c.SET};else if("markRead"in a)a={syncAction:{markChatAsReadAction:{read:a.markRead,messageRange:g(a.lastMessages)}},index:["markChatAsRead",b],type:"regular_low",apiVersion:3,operation:c.SET};else if("deleteForMe"in a){const {timestamp:f,key:h,deleteMedia:d}=a.deleteForMe;a={syncAction:{deleteMessageForMeAction:{deleteMedia:d,messageTimestamp:f}},index:["deleteMessageForMe",b,h.id,h.fromMe?"1":"0","0"],
+type:"regular_high",apiVersion:3,operation:c.SET}}else if("clear"in a)a={syncAction:{clearChatAction:{}},index:["clearChat",b,"1","0"],type:"regular_high",apiVersion:6,operation:c.SET};else if("pin"in a)a={syncAction:{pinAction:{pinned:!!a.pin}},index:["pin_v1",b],type:"regular_low",apiVersion:5,operation:c.SET};else if("star"in a)g=a.star.messages[0],a={syncAction:{starAction:{starred:!!a.star.star}},index:["star",b,g.id,g.fromMe?"1":"0","0"],type:"regular_low",apiVersion:2,operation:c.SET};else if("delete"in
+a)a={syncAction:{deleteChatAction:{messageRange:g(a.lastMessages)}},index:["deleteChat",b,"1"],type:"regular_high",apiVersion:6,operation:c.SET};else if("pushNameSetting"in a)a={syncAction:{pushNameSetting:{name:a.pushNameSetting}},index:["setting_pushName"],type:"critical_block",apiVersion:1,operation:c.SET};else if("addLabel"in a)a={syncAction:{labelEditAction:{name:a.addLabel.name,color:a.addLabel.color,predefinedId:a.addLabel.predefinedId,deleted:a.addLabel.deleted}},index:["label_edit",a.addLabel.id],
+type:"regular",apiVersion:3,operation:c.SET};else if("addChatLabel"in a)a={syncAction:{labelAssociationAction:{labeled:!0}},index:[LabelAssociation_1.LabelAssociationType.Chat,a.addChatLabel.labelId,b],type:"regular",apiVersion:3,operation:c.SET};else if("removeChatLabel"in a)a={syncAction:{labelAssociationAction:{labeled:!1}},index:[LabelAssociation_1.LabelAssociationType.Chat,a.removeChatLabel.labelId,b],type:"regular",apiVersion:3,operation:c.SET};else if("addMessageLabel"in a)a={syncAction:{labelAssociationAction:{labeled:!0}},
+index:[LabelAssociation_1.LabelAssociationType.Message,a.addMessageLabel.labelId,b,a.addMessageLabel.messageId,"0","0"],type:"regular",apiVersion:3,operation:c.SET};else if("removeMessageLabel"in a)a={syncAction:{labelAssociationAction:{labeled:!1}},index:[LabelAssociation_1.LabelAssociationType.Message,a.removeMessageLabel.labelId,b,a.removeMessageLabel.messageId,"0","0"],type:"regular",apiVersion:3,operation:c.SET};else throw new boom_1.Boom("not supported");a.syncAction.timestamp=Date.now();return a};
+exports.chatModificationToAppPatch=chatModificationToAppPatch;
+const processSyncAction=(a,b,c,g,f)=>{function h(x,t){return p?u=>{if(u=u.historySets.chats[x]||u.chatUpserts[x])return t?Number((null===t||void 0===t?void 0:t.lastMessageTimestamp)||(null===t||void 0===t?void 0:t.lastSystemMessageTimestamp)||0)>=Number((null===u||void 0===u?void 0:u.lastMessageRecvTimestamp)||0):!0}:void 0}var d,k,l,n;const p=!!g;var m=null===g||void 0===g?void 0:g.accountSettings;null===f||void 0===f||f.trace({syncAction:a,initialSync:!!g},"processing sync action");const {syncAction:{value:e},
+index:[r,q,v,w]}=a;if(null===e||void 0===e?0:e.muteAction)b.emit("chats.update",[{id:q,muteEndTime:(null===(d=e.muteAction)||void 0===d?0:d.muted)?(0,generics_1.toNumber)(e.muteAction.muteEndTimestamp):null,conditional:h(q,void 0)}]);else if((null===e||void 0===e?0:e.archiveChatAction)||"archive"===r||"unarchive"===r)a=null===e||void 0===e?void 0:e.archiveChatAction,b.emit("chats.update",[{id:q,archived:a?a.archived:"archive"===r,conditional:h(q,(null===m||void 0===m?0:m.unarchiveChats)?null===a||
+void 0===a?void 0:a.messageRange:void 0)}]);else if(null===e||void 0===e?0:e.markChatAsReadAction)m=e.markChatAsReadAction,b.emit("chats.update",[{id:q,unreadCount:p&&m.read?null:(null===m||void 0===m?0:m.read)?0:-1,conditional:h(q,null===m||void 0===m?void 0:m.messageRange)}]);else if((null===e||void 0===e?0:e.deleteMessageForMeAction)||"deleteMessageForMe"===r)b.emit("messages.delete",{keys:[{remoteJid:q,id:v,fromMe:"1"===w}]});else if(null===e||void 0===e?0:e.contactAction)b.emit("contacts.upsert",
+[{id:q,name:e.contactAction.fullName}]);else if(null===e||void 0===e?0:e.pushNameSetting)(m=null===(k=null===e||void 0===e?void 0:e.pushNameSetting)||void 0===k?void 0:k.name)&&(null===c||void 0===c?void 0:c.name)!==m&&b.emit("creds.update",{me:{...c,name:m}});else if(null===e||void 0===e?0:e.pinAction)b.emit("chats.update",[{id:q,pinned:(null===(l=e.pinAction)||void 0===l?0:l.pinned)?(0,generics_1.toNumber)(e.timestamp):null,conditional:h(q,void 0)}]);else if(null===e||void 0===e?0:e.unarchiveChatsSetting)a=
+!!e.unarchiveChatsSetting.unarchiveChats,b.emit("creds.update",{accountSettings:{unarchiveChats:a}}),null===f||void 0===f||f.info(`archive setting updated => '${e.unarchiveChatsSetting.unarchiveChats}'`),m&&(m.unarchiveChats=a);else if((null===e||void 0===e?0:e.starAction)||"star"===r)m=null===(n=null===e||void 0===e?void 0:e.starAction)||void 0===n?void 0:n.starred,"boolean"!==typeof m&&(m="1"===a.index[a.index.length-1]),b.emit("messages.update",[{key:{remoteJid:q,id:v,fromMe:"1"===w},update:{starred:m}}]);
+else if((null===e||void 0===e?0:e.deleteChatAction)||"deleteChat"===r)p||b.emit("chats.delete",[q]);else if(null===e||void 0===e?0:e.labelEditAction){const {name:x,color:t,deleted:u,predefinedId:y}=e.labelEditAction;b.emit("labels.edit",{id:q,name:x,color:t,deleted:u,predefinedId:y?String(y):void 0})}else(null===e||void 0===e?0:e.labelAssociationAction)?b.emit("labels.association",{type:e.labelAssociationAction.labeled?"add":"remove",association:r===LabelAssociation_1.LabelAssociationType.Chat?{type:LabelAssociation_1.LabelAssociationType.Chat,
+chatId:a.index[2],labelId:a.index[1]}:{type:LabelAssociation_1.LabelAssociationType.Message,chatId:a.index[2],messageId:a.index[3],labelId:a.index[1]}}):null===f||void 0===f||f.debug({syncAction:a,id:q},"unprocessable update")};exports.processSyncAction=processSyncAction;

package/lib/Utils/crypto.d.ts

@@ -0,0 +1,40 @@
+import { KeyPair } from '../Types';
+/** prefix version byte to the pub keys, required for some curve crypto functions */
+export declare const generateSignalPubKey: (pubKey: Uint8Array | Buffer) => Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
+export declare const Curve: {
+    generateKeyPair: () => KeyPair;
+    sharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => Buffer<any>;
+    sign: (privateKey: Uint8Array, buf: Uint8Array) => any;
+    verify: (pubKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => boolean;
+};
+export declare const signedKeyPair: (identityKeyPair: KeyPair, keyId: number) => {
+    keyPair: KeyPair;
+    signature: any;
+    keyId: number;
+};
+/**
+ * encrypt AES 256 GCM;
+ * where the tag tag is suffixed to the ciphertext
+ * */
+export declare function aesEncryptGCM(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer<ArrayBuffer>;
+/**
+ * decrypt AES 256 GCM;
+ * where the auth tag is suffixed to the ciphertext
+ * */
+export declare function aesDecryptGCM(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer<ArrayBuffer>;
+export declare function aesEncryptCTR(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer<ArrayBuffer>;
+export declare function aesDecryptCTR(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer<ArrayBuffer>;
+/** decrypt AES 256 CBC; where the IV is prefixed to the buffer */
+export declare function aesDecrypt(buffer: Buffer, key: Buffer): Buffer<ArrayBuffer>;
+/** decrypt AES 256 CBC */
+export declare function aesDecryptWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer<ArrayBuffer>;
+export declare function aesEncrypt(buffer: Buffer | Uint8Array, key: Buffer): Buffer<ArrayBuffer>;
+export declare function aesEncrypWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer<ArrayBuffer>;
+export declare function hmacSign(buffer: Buffer | Uint8Array, key: Buffer | Uint8Array, variant?: 'sha256' | 'sha512'): Buffer<ArrayBufferLike>;
+export declare function sha256(buffer: Buffer): Buffer<ArrayBufferLike>;
+export declare function md5(buffer: Buffer): Buffer<ArrayBufferLike>;
+export declare function hkdf(buffer: Uint8Array | Buffer, expandedLength: number, info: {
+    salt?: Buffer;
+    info?: string;
+}): Promise<Buffer>;
+export declare function derivePairingCodeKey(pairingCode: string, salt: Buffer): Promise<Buffer>;

package/lib/Utils/crypto.js

@@ -0,0 +1,11 @@
+var __createBinding=this&&this.__createBinding||(Object.create?function(b,a,c,d){void 0===d&&(d=c);var e=Object.getOwnPropertyDescriptor(a,c);if(!e||("get"in e?!a.__esModule:e.writable||e.configurable))e={enumerable:!0,get:function(){return a[c]}};Object.defineProperty(b,d,e)}:function(b,a,c,d){void 0===d&&(d=c);b[d]=a[c]}),__setModuleDefault=this&&this.__setModuleDefault||(Object.create?function(b,a){Object.defineProperty(b,"default",{enumerable:!0,value:a})}:function(b,a){b["default"]=a}),__importStar=
+this&&this.__importStar||function(){var b=function(a){b=Object.getOwnPropertyNames||function(c){var d=[],e;for(e in c)Object.prototype.hasOwnProperty.call(c,e)&&(d[d.length]=e);return d};return b(a)};return function(a){if(a&&a.__esModule)return a;var c={};if(null!=a)for(var d=b(a),e=0;e<d.length;e++)"default"!==d[e]&&__createBinding(c,a,d[e]);__setModuleDefault(c,a);return c}}();Object.defineProperty(exports,"__esModule",{value:!0});
+exports.signedKeyPair=exports.Curve=exports.generateSignalPubKey=void 0;exports.aesEncryptGCM=aesEncryptGCM;exports.aesDecryptGCM=aesDecryptGCM;exports.aesEncryptCTR=aesEncryptCTR;exports.aesDecryptCTR=aesDecryptCTR;exports.aesDecrypt=aesDecrypt;exports.aesDecryptWithIV=aesDecryptWithIV;exports.aesEncrypt=aesEncrypt;exports.aesEncrypWithIV=aesEncrypWithIV;exports.hmacSign=hmacSign;exports.sha256=sha256;exports.md5=md5;exports.hkdf=hkdf;exports.derivePairingCodeKey=derivePairingCodeKey;
+const crypto_1=require("crypto"),libsignal=__importStar(require("libsignal")),Defaults_1=require("../Defaults"),{subtle}=globalThis.crypto,generateSignalPubKey=b=>33===b.length?b:Buffer.concat([Defaults_1.KEY_BUNDLE_TYPE,b]);exports.generateSignalPubKey=generateSignalPubKey;
+exports.Curve={generateKeyPair:()=>{const {pubKey:b,privKey:a}=libsignal.curve.generateKeyPair();return{private:Buffer.from(a),public:Buffer.from(b.slice(1))}},sharedKey:(b,a)=>{b=libsignal.curve.calculateAgreement((0,exports.generateSignalPubKey)(a),b);return Buffer.from(b)},sign:(b,a)=>libsignal.curve.calculateSignature(b,a),verify:(b,a,c)=>{try{return libsignal.curve.verifySignature((0,exports.generateSignalPubKey)(b),a,c),!0}catch(d){return!1}}};
+const signedKeyPair=(b,a)=>{const c=exports.Curve.generateKeyPair(),d=(0,exports.generateSignalPubKey)(c.public);b=exports.Curve.sign(b.private,d);return{keyPair:c,signature:b,keyId:a}};exports.signedKeyPair=signedKeyPair;const GCM_TAG_LENGTH=16;function aesEncryptGCM(b,a,c,d){a=(0,crypto_1.createCipheriv)("aes-256-gcm",a,c);a.setAAD(d);return Buffer.concat([a.update(b),a.final(),a.getAuthTag()])}
+function aesDecryptGCM(b,a,c,d){a=(0,crypto_1.createDecipheriv)("aes-256-gcm",a,c);c=b.slice(0,b.length-GCM_TAG_LENGTH);b=b.slice(b.length-GCM_TAG_LENGTH);a.setAAD(d);a.setAuthTag(b);return Buffer.concat([a.update(c),a.final()])}function aesEncryptCTR(b,a,c){a=(0,crypto_1.createCipheriv)("aes-256-ctr",a,c);return Buffer.concat([a.update(b),a.final()])}function aesDecryptCTR(b,a,c){a=(0,crypto_1.createDecipheriv)("aes-256-ctr",a,c);return Buffer.concat([a.update(b),a.final()])}
+function aesDecrypt(b,a){return aesDecryptWithIV(b.slice(16,b.length),a,b.slice(0,16))}function aesDecryptWithIV(b,a,c){a=(0,crypto_1.createDecipheriv)("aes-256-cbc",a,c);return Buffer.concat([a.update(b),a.final()])}function aesEncrypt(b,a){const c=(0,crypto_1.randomBytes)(16);a=(0,crypto_1.createCipheriv)("aes-256-cbc",a,c);return Buffer.concat([c,a.update(b),a.final()])}
+function aesEncrypWithIV(b,a,c){a=(0,crypto_1.createCipheriv)("aes-256-cbc",a,c);return Buffer.concat([a.update(b),a.final()])}function hmacSign(b,a,c="sha256"){return(0,crypto_1.createHmac)(c,a).update(b).digest()}function sha256(b){return(0,crypto_1.createHash)("sha256").update(b).digest()}function md5(b){return(0,crypto_1.createHash)("md5").update(b).digest()}
+async function hkdf(b,a,c){var d=b instanceof Uint8Array?b:new Uint8Array(b);b=c.salt?new Uint8Array(c.salt):new Uint8Array(0);c=c.info?(new TextEncoder).encode(c.info):new Uint8Array(0);d=await subtle.importKey("raw",d,{name:"HKDF"},!1,["deriveBits"]);a=await subtle.deriveBits({name:"HKDF",hash:"SHA-256",salt:b,info:c},d,8*a);return Buffer.from(a)}
+async function derivePairingCodeKey(b,a){b=(new TextEncoder).encode(b);a=a instanceof Uint8Array?a:new Uint8Array(a);b=await subtle.importKey("raw",b,{name:"PBKDF2"},!1,["deriveBits"]);a=await subtle.deriveBits({name:"PBKDF2",salt:a,iterations:131072,hash:"SHA-256"},b,256);return Buffer.from(a)};