@aseppxyzz12/baileys 1.1.8

package/lib/Defaults/constants.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const UNAUTHORIZED_CODES = [401, 403, 419];
+const PHONENUMBER_MCC = require("./phonenumber-mcc.json");
+const DEFAULT_ORIGIN = "https://web.whatsapp.com";
+const PHONE_CONNECTION_CB = "CB:Pong";
+const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+const WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
+const WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
+const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+const NOISE_MODE = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+const DICT_VERSION = 3;
+const KEY_BUNDLE_TYPE = Buffer.from([5]);
+const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]);
+const URL_REGEX =
+    /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
+const MIN_PREKEY_COUNT = 5;
+const INITIAL_PREKEY_COUNT = 812;
+const UPLOAD_TIMEOUT = 3e4;
+const MIN_UPLOAD_INTERVAL = 5e3;
+const WA_CERT_DETAILS = { SERIAL: 0 };
+const DEFAULT_CACHE_TTLS = {
+    SIGNAL_STORE: 5 * 60,
+    MSG_RETRY: 60 * 60,
+    CALL_OFFER: 5 * 60,
+    USER_DEVICES: 5 * 60,
+};
+module.exports = {
+    UNAUTHORIZED_CODES: UNAUTHORIZED_CODES,
+    PHONENUMBER_MCC: PHONENUMBER_MCC,
+    DEFAULT_ORIGIN: DEFAULT_ORIGIN,
+    PHONE_CONNECTION_CB: PHONE_CONNECTION_CB,
+    WA_ADV_ACCOUNT_SIG_PREFIX: WA_ADV_ACCOUNT_SIG_PREFIX,
+    WA_ADV_DEVICE_SIG_PREFIX: WA_ADV_DEVICE_SIG_PREFIX,
+    WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX: WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX,
+    WA_ADV_HOSTED_DEVICE_SIG_PREFIX: WA_ADV_HOSTED_DEVICE_SIG_PREFIX,
+    WA_DEFAULT_EPHEMERAL: WA_DEFAULT_EPHEMERAL,
+    NOISE_MODE: NOISE_MODE,
+    DICT_VERSION: DICT_VERSION,
+    KEY_BUNDLE_TYPE: KEY_BUNDLE_TYPE,
+    NOISE_WA_HEADER: NOISE_WA_HEADER,
+    URL_REGEX: URL_REGEX,
+    MIN_PREKEY_COUNT: MIN_PREKEY_COUNT,
+    MIN_UPLOAD_INTERVAL: MIN_UPLOAD_INTERVAL,
+    INITIAL_PREKEY_COUNT: INITIAL_PREKEY_COUNT,
+    UPLOAD_TIMEOUT: UPLOAD_TIMEOUT,
+    WA_CERT_DETAILS: WA_CERT_DETAILS,
+    DEFAULT_CACHE_TTLS: DEFAULT_CACHE_TTLS,
+};

package/lib/Defaults/history.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { proto: proto } = require("../../WAProto");
+const PROCESSABLE_HISTORY_TYPES = [
+    proto.Message.HistorySyncType.INITIAL_BOOTSTRAP,
+    proto.Message.HistorySyncType.PUSH_NAME,
+    proto.Message.HistorySyncType.RECENT,
+    proto.Message.HistorySyncType.FULL,
+    proto.Message.HistorySyncType.ON_DEMAND,
+    proto.HistorySync.HistorySyncType.NON_BLOCKING_DATA,
+    proto.HistorySync.HistorySyncType.INITIAL_STATUS_V3,
+];
+module.exports = { PROCESSABLE_HISTORY_TYPES: PROCESSABLE_HISTORY_TYPES };

package/lib/Defaults/index.js

@@ -0,0 +1,36 @@
+"use strict";
+const __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              let desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+const __exportStar =
+    (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m) {
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) {
+                __createBinding(exports, m, p);
+            }
+        }
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./connection"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./history"), exports);
+__exportStar(require("./media"), exports);
+__exportStar(require("./prefix"), exports);

package/lib/Defaults/media.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MEDIA_PATH_MAP = {
+    image: "/mms/image",
+    video: "/mms/video",
+    document: "/mms/document",
+    audio: "/mms/audio",
+    sticker: "/mms/image",
+    "sticker-pack": "/mms/sticker",
+    "thumbnail-link": "/mms/image",
+    "product-catalog-image": "/product/image",
+    "md-app-state": "",
+    "md-msg-hist": "/mms/md-app-state",
+    "biz-cover-photo": "/pps/biz-cover-photo",
+};
+const MEDIA_HKDF_KEY_MAPPING = {
+    audio: "Audio",
+    document: "Document",
+    gif: "Video",
+    image: "Image",
+    ppic: "",
+    product: "Image",
+    ptt: "Audio",
+    video: "Video",
+    sticker: "Image",
+    "sticker-pack": "Sticker Pack",
+    "thumbnail-document": "Document Thumbnail",
+    "thumbnail-image": "Image Thumbnail",
+    "thumbnail-video": "Video Thumbnail",
+    "thumbnail-link": "Link Thumbnail",
+    "md-msg-hist": "History",
+    "md-app-state": "App State",
+    "product-catalog-image": "",
+    "payment-bg-image": "Payment Background",
+    ptv: "Video",
+    "biz-cover-photo": "Image",
+};
+const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
+module.exports = {
+    MEDIA_KEYS: MEDIA_KEYS,
+    MEDIA_PATH_MAP: MEDIA_PATH_MAP,
+    MEDIA_HKDF_KEY_MAPPING: MEDIA_HKDF_KEY_MAPPING,
+};

package/lib/Defaults/phonenumber-mcc.json

@@ -0,0 +1,223 @@
+{
+    "93": 412,
+    "355": 276,
+    "213": 603,
+    "1-684": 544,
+    "376": 213,
+    "244": 631,
+    "1-264": 365,
+    "1-268": 344,
+    "54": 722,
+    "374": 283,
+    "297": 363,
+    "61": 505,
+    "43": 232,
+    "994": 400,
+    "1-242": 364,
+    "973": 426,
+    "880": 470,
+    "1-246": 342,
+    "375": 257,
+    "32": 206,
+    "501": 702,
+    "229": 616,
+    "1-441": 350,
+    "975": 402,
+    "591": 736,
+    "387": 218,
+    "267": 652,
+    "55": 724,
+    "1-284": 348,
+    "673": 528,
+    "359": 284,
+    "226": 613,
+    "257": 642,
+    "855": 456,
+    "237": 624,
+    "238": 625,
+    "1-345": 346,
+    "236": 623,
+    "235": 622,
+    "56": 730,
+    "86": 454,
+    "57": 732,
+    "269": 654,
+    "682": 548,
+    "506": 712,
+    "385": 219,
+    "53": 368,
+    "357": 280,
+    "420": 230,
+    "243": 630,
+    "45": 238,
+    "253": 638,
+    "1-767": 366,
+    "1-809": 370,
+    "1-849": 370,
+    "1-829": 370,
+    "593": 740,
+    "20": 602,
+    "503": 706,
+    "240": 627,
+    "291": 657,
+    "372": 248,
+    "251": 636,
+    "500": 750,
+    "298": 288,
+    "679": 542,
+    "358": 244,
+    "33": 208,
+    "689": 547,
+    "241": 628,
+    "220": 607,
+    "995": 282,
+    "49": 262,
+    "233": 620,
+    "350": 266,
+    "30": 202,
+    "299": 290,
+    "1-473": 352,
+    "1-671": 535,
+    "502": 704,
+    "224": 537,
+    "592": 738,
+    "509": 372,
+    "504": 708,
+    "852": 454,
+    "36": 216,
+    "354": 274,
+    "91": 404,
+    "62": 510,
+    "98": 432,
+    "964": 418,
+    "353": 234,
+    "972": 425,
+    "39": 222,
+    "225": 612,
+    "1-876": 338,
+    "81": 440,
+    "962": 416,
+    "254": 639,
+    "686": 545,
+    "383": 221,
+    "965": 419,
+    "371": 247,
+    "961": 415,
+    "266": 651,
+    "231": 618,
+    "218": 606,
+    "423": 295,
+    "370": 246,
+    "352": 270,
+    "389": 294,
+    "261": 646,
+    "265": 650,
+    "60": 502,
+    "960": 472,
+    "223": 610,
+    "356": 278,
+    "692": 551,
+    "222": 609,
+    "230": 617,
+    "52": 334,
+    "691": 550,
+    "373": 259,
+    "377": 212,
+    "976": 428,
+    "382": 297,
+    "1-664": 354,
+    "212": 604,
+    "258": 643,
+    "95": 414,
+    "264": 649,
+    "674": 536,
+    "977": 429,
+    "31": 204,
+    "687": 546,
+    "64": 530,
+    "505": 710,
+    "227": 614,
+    "234": 621,
+    "683": 555,
+    "1-670": 534,
+    "47": 242,
+    "968": 226,
+    "92": 410,
+    "680": 552,
+    "970": 423,
+    "507": 714,
+    "675": 537,
+    "595": 744,
+    "51": 716,
+    "63": 515,
+    "48": 260,
+    "351": 268,
+    "1-787, 1-939": 330,
+    "974": 427,
+    "242": 630,
+    "40": 226,
+    "7": 250,
+    "250": 635,
+    "290": 658,
+    "1-869": 356,
+    "1-758": 358,
+    "508": 308,
+    "1-784": 360,
+    "685": 544,
+    "378": 292,
+    "239": 626,
+    "966": 420,
+    "221": 608,
+    "381": 220,
+    "248": 633,
+    "232": 619,
+    "65": 525,
+    "386": 293,
+    "677": 540,
+    "27": 655,
+    "211": 659,
+    "34": 214,
+    "94": 413,
+    "249": 634,
+    "597": 746,
+    "268": 653,
+    "46": 240,
+    "41": 228,
+    "963": 417,
+    "886": 466,
+    "992": 436,
+    "255": 640,
+    "66": 520,
+    "228": 615,
+    "690": 554,
+    "676": 539,
+    "1-868": 374,
+    "216": 605,
+    "90": 286,
+    "993": 438,
+    "1-649": 376,
+    "688": 553,
+    "1-340": 332,
+    "256": 641,
+    "380": 255,
+    "971": 424,
+    "44": 234,
+    "1": 310,
+    "598": 748,
+    "998": 434,
+    "678": 541,
+    "379": 225,
+    "58": 734,
+    "681": 543,
+    "967": 421,
+    "260": 645,
+    "263": 648,
+    "670": 514,
+    "245": 632,
+    "856": 457,
+    "599": 362,
+    "850": 467,
+    "262": 647,
+    "82": 450,
+    "84": 452
+}

package/lib/Defaults/prefix.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DEF_TAG_PREFIX = "TAG:";
+const DEF_CALLBACK_PREFIX = "CB:";
+const CALL_VIDEO_PREFIX = "https://call.whatsapp.com/video/";
+const CALL_AUDIO_PREFIX = "https://call.whatsapp.com/voice/";
+module.exports = {
+    DEF_TAG_PREFIX: DEF_TAG_PREFIX,
+    DEF_CALLBACK_PREFIX: DEF_CALLBACK_PREFIX,
+    CALL_VIDEO_PREFIX: CALL_VIDEO_PREFIX,
+    CALL_AUDIO_PREFIX: CALL_AUDIO_PREFIX,
+};

package/lib/Function/Download/tiktok.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+const fetch = require("node-fetch");
+const pkg = require("../../../package.json");
+
+async function TikTok(url) {
+    const base = pkg.profile.baseurl;
+
+    const res = await fetch(
+        `${base}/download/tiktok?url=${encodeURIComponent(url)}`
+    );
+
+    return await res.json();
+}
+
+exports.TikTok = TikTok;

package/lib/Function/Tools/bypass.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+const fetch = require("node-fetch");
+const pkg = require("../../../package.json");
+
+async function BypassTurnstileMin(url, siteKey) {
+    const base = pkg.profile.baseurl;
+
+    const res = await fetch(
+        `${base}/tools/turnstile-min?url=${encodeURIComponent(url)}&siteKey=${encodeURIComponent(siteKey)}`
+    );
+
+    return await res.json();
+}
+
+exports.BypassTurnstileMin = BypassTurnstileMin;

package/lib/Function/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+// tools
+const { BypassTurnstileMin } = require("./Tools/bypass");
+
+// downloader
+const { TikTok } = require("./Download/tiktok");
+
+exports.TikTok = TikTok
+exports.BypassTurnstileMin = BypassTurnstileMin;

package/lib/Signal/Group/ciphertext-message.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CiphertextMessage {
+    constructor() {
+        this.UNSUPPORTED_VERSION = 1;
+        this.CURRENT_VERSION = 3;
+        this.WHISPER_TYPE = 2;
+        this.PREKEY_TYPE = 3;
+        this.SENDERKEY_TYPE = 4;
+        this.SENDERKEY_DISTRIBUTION_TYPE = 5;
+        this.ENCRYPTED_MESSAGE_OVERHEAD = 53;
+    }
+}
+module.exports = { CiphertextMessage: CiphertextMessage };

package/lib/Signal/Group/group-session-builder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const {
+    generateSenderKey: generateSenderKey,
+    generateSenderKeyId: generateSenderKeyId,
+    generateSenderSigningKey: generateSenderSigningKey,
+} = require("./keyhelper");
+const {
+    SenderKeyDistributionMessage: SenderKeyDistributionMessage,
+} = require("./sender-key-distribution-message");
+class GroupSessionBuilder {
+    constructor(senderKeyStore) {
+        this.senderKeyStore = senderKeyStore;
+    }
+    async process(senderKeyName, senderKeyDistributionMessage) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        senderKeyRecord.addSenderKeyState(
+            senderKeyDistributionMessage.getId(),
+            senderKeyDistributionMessage.getIteration(),
+            senderKeyDistributionMessage.getChainKey(),
+            senderKeyDistributionMessage.getSignatureKey()
+        );
+        await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+    async create(senderKeyName) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        if (senderKeyRecord.isEmpty()) {
+            const keyId = generateSenderKeyId();
+            const senderKey = generateSenderKey();
+            const signingKey = generateSenderSigningKey();
+            senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+            await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+        }
+        const state = senderKeyRecord.getSenderKeyState();
+        if (!state) {
+            throw new Error("No session state available");
+        }
+        return new SenderKeyDistributionMessage(
+            state.getKeyId(),
+            state.getSenderChainKey().getIteration(),
+            state.getSenderChainKey().getSeed(),
+            state.getSigningKeyPublic()
+        );
+    }
+}
+module.exports = { GroupSessionBuilder: GroupSessionBuilder };

package/lib/Signal/Group/group_cipher.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { decrypt: decrypt, encrypt: encrypt } = require("libsignal/src/crypto");
+const { SenderKeyMessage: SenderKeyMessage } = require("./sender-key-message");
+class GroupCipher {
+    constructor(senderKeyStore, senderKeyName) {
+        this.senderKeyStore = senderKeyStore;
+        this.senderKeyName = senderKeyName;
+    }
+    async encrypt(paddedPlaintext) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error("No SenderKeyRecord found for encryption");
+        }
+        const senderKeyState = record.getSenderKeyState();
+        if (!senderKeyState) {
+            throw new Error("No session to encrypt message");
+        }
+        const iteration = senderKeyState.getSenderChainKey().getIteration();
+        const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+        const ciphertext = await this.getCipherText(
+            senderKey.getIv(),
+            senderKey.getCipherKey(),
+            paddedPlaintext
+        );
+        const senderKeyMessage = new SenderKeyMessage(
+            senderKeyState.getKeyId(),
+            senderKey.getIteration(),
+            ciphertext,
+            senderKeyState.getSigningKeyPrivate()
+        );
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return senderKeyMessage.serialize();
+    }
+    async decrypt(senderKeyMessageBytes) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error("No SenderKeyRecord found for decryption");
+        }
+        const senderKeyMessage = new SenderKeyMessage(
+            null,
+            null,
+            null,
+            null,
+            senderKeyMessageBytes
+        );
+        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+        if (!senderKeyState) {
+            throw new Error("No session found to decrypt message");
+        }
+        senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+        const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+        const plaintext = await this.getPlainText(
+            senderKey.getIv(),
+            senderKey.getCipherKey(),
+            senderKeyMessage.getCipherText()
+        );
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return plaintext;
+    }
+    getSenderKey(senderKeyState, iteration) {
+        let senderChainKey = senderKeyState.getSenderChainKey();
+        if (senderChainKey.getIteration() > iteration) {
+            if (senderKeyState.hasSenderMessageKey(iteration)) {
+                const messageKey = senderKeyState.removeSenderMessageKey(iteration);
+                if (!messageKey) {
+                    throw new Error("No sender message key found for iteration");
+                }
+                return messageKey;
+            }
+            throw new Error(
+                `Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`
+            );
+        }
+        if (iteration - senderChainKey.getIteration() > 2e3) {
+            throw new Error("Over 2000 messages into the future!");
+        }
+        while (senderChainKey.getIteration() < iteration) {
+            senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+            senderChainKey = senderChainKey.getNext();
+        }
+        senderKeyState.setSenderChainKey(senderChainKey.getNext());
+        return senderChainKey.getSenderMessageKey();
+    }
+    async getPlainText(iv, key, ciphertext) {
+        try {
+            return decrypt(key, ciphertext, iv);
+        } catch (e) {
+            throw new Error("InvalidMessageException");
+        }
+    }
+    async getCipherText(iv, key, plaintext) {
+        try {
+            const ivBuffer = typeof iv === "string" ? Buffer.from(iv, "base64") : iv;
+            const keyBuffer = typeof key === "string" ? Buffer.from(key, "base64") : key;
+            const plaintextBuffer =
+                typeof plaintext === "string" ? Buffer.from(plaintext) : plaintext;
+            return encrypt(keyBuffer, plaintextBuffer, ivBuffer);
+        } catch (e) {
+            throw new Error("InvalidMessageException");
+        }
+    }
+}
+module.exports = { GroupCipher: GroupCipher };

package/lib/Signal/Group/index.js

@@ -0,0 +1,42 @@
+"use strict";
+const __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              let desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+const __exportStar =
+    (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m) {
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) {
+                __createBinding(exports, m, p);
+            }
+        }
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ciphertext-message"), exports);
+__exportStar(require("./group-session-builder"), exports);
+__exportStar(require("./group_cipher"), exports);
+__exportStar(require("./keyhelper"), exports);
+__exportStar(require("./sender-chain-key"), exports);
+__exportStar(require("./sender-key-distribution-message"), exports);
+__exportStar(require("./sender-key-message"), exports);
+__exportStar(require("./sender-key-name"), exports);
+__exportStar(require("./sender-key-record"), exports);
+__exportStar(require("./sender-key-state"), exports);
+__exportStar(require("./sender-message-key"), exports);

package/lib/Signal/Group/keyhelper.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { randomInt: randomInt, randomBytes: randomBytes } = require("crypto");
+const { generateKeyPair: generateKeyPair } = require("libsignal/src/curve");
+function generateSenderKey() {
+    return randomBytes(32);
+}
+function generateSenderKeyId() {
+    return randomInt(2147483647);
+}
+function generateSenderSigningKey(key) {
+    if (!key) {
+        key = generateKeyPair();
+    }
+    return { public: Buffer.from(key.pubKey), private: Buffer.from(key.privKey) };
+}
+module.exports = {
+    generateSenderKey: generateSenderKey,
+    generateSenderKeyId: generateSenderKeyId,
+    generateSenderSigningKey: generateSenderSigningKey,
+};