sauruspro-bail 5.0.0 → 5.0.2-alpha.spr.test

package/lib/Utils/native-flow.js

@@ -0,0 +1,118 @@
+
+const NATIVE_FLOW_NAMES = Object.freeze([
+    'booking_confirmation',
+    'order_details',
+    'order_status',
+    'payment_status',
+    'payment_method',
+    'payment_reminder',
+    'message_with_link',
+    'message_with_link_status',
+    'quick_reply',
+    'cta_call',
+    'cta_url',
+    'cta_catalog',
+    'catalog_message',
+    'payment_info',
+    'cta_copy',
+    'mixed',
+    'galaxy_message',
+    'cta_app',
+    'call_permission_request',
+    'payment_request',
+    'api_signup',
+    'inapp_signup',
+    'form_message',
+    'menu_options',
+    'a2ui_reply_action',
+    'address_message',
+    'mpm'
+]);
+
+const BUTTON_NAME_TO_FLOW = Object.freeze({
+    review_and_pay: 'order_details',
+    payment_info: 'payment_info',
+    review_order: 'order_status',
+    order_status: 'order_status',
+    payment_status: 'payment_status',
+    payment_method: 'payment_method',
+    open_webview: 'message_with_link',
+    message_with_link_status: 'message_with_link_status',
+    cta_url: 'cta_url',
+    cta_call: 'cta_call',
+    quick_reply: 'quick_reply',
+    catalog_message: 'catalog_message',
+    cta_catalog: 'cta_catalog',
+    cta_copy: 'cta_copy',
+    galaxy_message: 'galaxy_message',
+    payment_reminder: 'payment_reminder',
+    booking_confirmation: 'booking_confirmation',
+    call_permission_request: 'call_permission_request',
+    payment_request: 'payment_request',
+    api_signup: 'api_signup',
+    inapp_signup: 'inapp_signup',
+    cta_app: 'cta_app',
+    form_message: 'form_message',
+    address_message: 'address_message',
+    mpm: 'mpm'
+});
+
+const WEB_SUPPORTED_INTERACTIVE_FLOWS = Object.freeze([
+    'quick_reply',
+    'cta_call',
+    'cta_url',
+    'cta_catalog',
+    'catalog_message',
+    'cta_copy',
+    'galaxy_message',
+    'order_status',
+    'payment_reminder',
+    'booking_confirmation',
+    'payment_request',
+    'api_signup',
+    'inapp_signup',
+    'cta_app',
+    'form_message'
+]);
+
+const NATIVE_FLOW_BUTTON_LIMIT = Object.freeze({
+    quickReply: 10,
+    other: 3
+});
+
+const getNativeFlowNameByButtonName = (name) => BUTTON_NAME_TO_FLOW[name];
+
+const isWebSupportedButtonName = (name) => {
+    const flow = getNativeFlowNameByButtonName(name);
+    return flow !== undefined && WEB_SUPPORTED_INTERACTIVE_FLOWS.includes(flow);
+};
+
+const checkNativeFlowButtons = (buttons) => {
+    const list = (Array.isArray(buttons) ? buttons : []).map(button => (typeof button === 'string' ? { name: button } : button));
+    const problems = [];
+
+    if (!list.length) {
+        return { ok: true, limit: NATIVE_FLOW_BUTTON_LIMIT.other, problems, unsupported: [] };
+    }
+
+    const firstIsQuickReply = list[0]?.name === 'quick_reply';
+    const limit = firstIsQuickReply ? NATIVE_FLOW_BUTTON_LIMIT.quickReply : NATIVE_FLOW_BUTTON_LIMIT.other;
+
+    if (list.length > limit) {
+        problems.push(`WhatsApp Web renders at most ${limit} buttons when the first one is ${firstIsQuickReply ? 'quick_reply' : 'not quick_reply'}, got ${list.length}`);
+    }
+
+    const unsupported = [...new Set(list.map(button => button?.name).filter(name => !isWebSupportedButtonName(name)))];
+    for (const name of unsupported) {
+        problems.push(`"${name}" is not a native flow WhatsApp Web or iOS can render, only Android shows it`);
+    }
+
+    const mixesKinds = list.slice(1).some(button => (button?.name === 'quick_reply') !== firstIsQuickReply);
+    if (mixesKinds) {
+        problems.push('quick_reply buttons cannot be mixed with other button types in one message');
+    }
+
+    return { ok: problems.length === 0, limit, problems, unsupported };
+};
+
+export { NATIVE_FLOW_NAMES, WEB_SUPPORTED_INTERACTIVE_FLOWS, NATIVE_FLOW_BUTTON_LIMIT, getNativeFlowNameByButtonName, isWebSupportedButtonName, checkNativeFlowButtons };

package/lib/Utils/newsletter-status.js

@@ -1,58 +1,10 @@
-/**
- * Newsletter Status (Channel Status) for sauruspro-bail
- * Owner: Saurus / Dinolith
- *
- * Send, react, revoke and fetch WhatsApp Channel (newsletter) statuses.
- * ESM port, uses only local sauruspro-bail modules.
- */
 import { proto } from '../../WAProto/index.js';
 import { encodeNewsletterMessage, generateMessageIDV2 } from './generics.js';
 import { generateWAMessage, normalizeMessageContent } from './messages.js';
+import { prepareModernMessageContent, makeNewsletterStatusAttribution } from './modern-messages.js';
 import { WAMessageStatus } from '../Types/Message.js';
-import { getBinaryNodeChild, getBinaryNodeChildren, S_WHATSAPP_NET, isJidNewsletter } from '../WABinary/index.js';
-
-/**
- * Minimal content preparer (replaces the big modern-messages layer).
- * Supports: content.newsletterStatus = { newsletterJid, messageId, actionUrl?, duration?, hasMultipleReshares? }
- *           content.statusAttributions = [...]
- */
-export const makeNewsletterStatusAttribution = input => {
-    if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('newsletterStatus must be an object')
-    if (!input.newsletterJid) throw new TypeError('newsletterStatus.newsletterJid is required')
-    if (input.messageId === undefined || input.messageId === null) throw new TypeError('newsletterStatus.messageId is required')
-    return proto.StatusAttribution.create({
-        type: proto.StatusAttribution.Type.NEWSLETTER_STATUS,
-        actionUrl: input.actionUrl,
-        statusReshare: {
-            source: proto.StatusAttribution.StatusReshare.Source.CHANNEL_RESHARE,
-            metadata: {
-                duration: input.duration,
-                channelJid: input.newsletterJid,
-                channelMessageId: Number(input.messageId),
-                hasMultipleReshares: input.hasMultipleReshares ?? false
-            }
-        }
-    })
-}
-
-export const prepareNewsletterStatusContent = content => {
-    if (!content || typeof content !== 'object' || Array.isArray(content)) return content
-    const output = { ...content }
-    const attributions = Array.isArray(output.contextInfo?.statusAttributions) ? [...output.contextInfo.statusAttributions] : []
-    if (output.newsletterStatus) {
-        attributions.push(makeNewsletterStatusAttribution(output.newsletterStatus))
-        delete output.newsletterStatus
-    }
-    if (Array.isArray(output.statusAttributions)) {
-        attributions.push(...output.statusAttributions)
-        delete output.statusAttributions
-    }
-    if (attributions.length) {
-        output.contextInfo = { ...(output.contextInfo || {}), statusAttributions: attributions }
-    }
-    return output
-}
-
+import { getBinaryNodeChild, getBinaryNodeChildren, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { isJidNewsletter } from '../WABinary/jid-utils.js';
 
 const NEWSLETTER_STATUS_MEDIA_TYPES = new Set(['audio', 'gif', 'image', 'video'])
 const NEWSLETTER_STATUS_WEB_MEDIA_TYPES = new Set(['image', 'video'])
@@ -448,7 +400,7 @@ export const makeNewsletterStatusSender = (sock, config) => async (jid, content,
         return result
     }
 
-    const preparedContent = prepareNewsletterStatusContent(content)
+    const preparedContent = prepareModernMessageContent(content)
     const fullMsg = await generateWAMessage(jid, statusAttribution ? withNewsletterStatusAttribution(preparedContent) : preparedContent, {
         logger: config?.logger,
         userJid,
@@ -735,4 +687,8 @@ export const getNewsletterStatusUpdates = (sock, jid, options) => {
     return makeNewsletterStatusUpdatesFetcher(sock)(jid, options);
 };
 
-export { NEWSLETTER_STATUS_CONTENT_TYPES, NEWSLETTER_STATUS_MEDIA_TYPES, NEWSLETTER_STATUS_WEB_MEDIA_TYPES }
+export { NEWSLETTER_STATUS_CONTENT_TYPES, NEWSLETTER_STATUS_MEDIA_TYPES, NEWSLETTER_STATUS_WEB_MEDIA_TYPES };
+
+// compat dengan API sauruspro sebelumnya
+export { makeNewsletterStatusAttribution };
+export const prepareNewsletterStatusContent = prepareModernMessageContent;

package/lib/Utils/payment-messages.d.ts

@@ -0,0 +1,59 @@
+export const SplitPaymentStatus: {
+    readonly PENDING: 0;
+    readonly PAID: 1;
+};
+export const ReminderFrequency: {
+    readonly REMINDER_FREQUENCY_UNKNOWN: 0;
+    readonly WEEKLY: 1;
+    readonly BI_WEEKLY: 2;
+    readonly MONTHLY: 3;
+    readonly QUARTERLY: 4;
+};
+export const ReminderStatus: {
+    readonly REMINDER_STATUS_UNKNOWN: 0;
+    readonly ACTIVE: 1;
+    readonly CANCELLED_BY_CREATOR: 2;
+    readonly STOPPED_BY_RECEIVER: 3;
+    readonly EXPIRED: 4;
+    readonly PAID: 5;
+};
+export const MONEY_OFFSET: 1000;
+export const money: (amount: any, currencyCode: any, offset?: number) => {
+    value: number;
+    offset: number;
+    currencyCode: string;
+};
+export const readMoney: (value: any) => {
+    amount: number;
+    currencyCode: any;
+} | undefined;
+export const buildSplitPayment: ({ splitId, total, currency, description, requesterJid, participants, createdAt }?: {
+    splitId?: any;
+    total?: any;
+    currency?: any;
+    description?: any;
+    requesterJid?: any;
+    participants?: any[] | undefined;
+    createdAt?: any;
+}) => any;
+export const buildSplitPaymentUpdate: ({ splitId, participantJid }?: {
+    splitId?: any;
+    participantJid?: any;
+}) => {
+    splitId: string;
+    participantJid: any;
+};
+export const buildPaymentReminder: ({ reminderId, instanceId, description, frequency, status, amount, currency, payeeVpa, payeeJid, payerJid }?: {
+    reminderId?: any;
+    instanceId?: any;
+    description?: any;
+    frequency?: number | undefined;
+    status?: number | undefined;
+    amount?: any;
+    currency?: any;
+    payeeVpa?: any;
+    payeeJid?: any;
+    payerJid?: any;
+}) => any;
+export const readSplitPayment: (msg: any) => any;
+export const readPaymentReminder: (msg: any) => any;

package/lib/Utils/payment-messages.js

@@ -0,0 +1,156 @@
+
+const SplitPaymentStatus = Object.freeze({ PENDING: 0, PAID: 1 });
+
+const ReminderFrequency = Object.freeze({
+    REMINDER_FREQUENCY_UNKNOWN: 0,
+    WEEKLY: 1,
+    BI_WEEKLY: 2,
+    MONTHLY: 3,
+    QUARTERLY: 4
+});
+
+const ReminderStatus = Object.freeze({
+    REMINDER_STATUS_UNKNOWN: 0,
+    ACTIVE: 1,
+    CANCELLED_BY_CREATOR: 2,
+    STOPPED_BY_RECEIVER: 3,
+    EXPIRED: 4,
+    PAID: 5
+});
+
+const MONEY_OFFSET = 1000;
+
+const drop = (object) => {
+    for (const key of Object.keys(object)) {
+        if (object[key] === undefined || object[key] === null) {
+            delete object[key];
+        }
+    }
+    return object;
+};
+
+const money = (amount, currencyCode, offset = MONEY_OFFSET) => {
+    const value = Number(amount);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeError('money needs a non-negative amount');
+    }
+    if (typeof currencyCode !== 'string' || currencyCode.length !== 3) {
+        throw new TypeError('money needs a three letter currency code, like IDR or USD');
+    }
+    if (!Number.isInteger(offset) || offset <= 0) {
+        throw new TypeError('money offset must be a positive integer');
+    }
+    return { value: Math.round(value * offset), offset, currencyCode: currencyCode.toUpperCase() };
+};
+
+const readMoney = (value) => {
+    if (!value?.offset) {
+        return undefined;
+    }
+    return {
+        amount: Number(value.value) / Number(value.offset),
+        currencyCode: value.currencyCode
+    };
+};
+
+const buildSplitPayment = ({ splitId, total, currency, description, requesterJid, participants = [], createdAt } = {}) => {
+    if (!splitId) {
+        throw new TypeError('buildSplitPayment needs a splitId, the update message is keyed on it');
+    }
+    if (!participants.length) {
+        throw new TypeError('buildSplitPayment needs at least one participant');
+    }
+    return drop({
+        splitId: String(splitId),
+        totalAmount: total === undefined ? undefined : (0, money)(total, currency),
+        description,
+        requesterJid,
+        participants: participants.map((participant, index) => {
+            if (!participant?.jid) {
+                throw new TypeError(`participant ${index} needs a jid`);
+            }
+            return drop({
+                jid: participant.jid,
+                amount: participant.amount === undefined ? undefined : (0, money)(participant.amount, participant.currency ?? currency),
+                status: participant.status ?? SplitPaymentStatus.PENDING
+            });
+        }),
+        createdAtMs: createdAt === undefined ? Date.now() : Number(createdAt)
+    });
+};
+
+const buildSplitPaymentUpdate = ({ splitId, participantJid } = {}) => {
+    if (!splitId || !participantJid) {
+        throw new TypeError('buildSplitPaymentUpdate needs both splitId and participantJid');
+    }
+    return { splitId: String(splitId), participantJid };
+};
+
+const buildPaymentReminder = ({
+    reminderId,
+    instanceId,
+    description,
+    frequency = ReminderFrequency.MONTHLY,
+    status = ReminderStatus.ACTIVE,
+    amount,
+    currency,
+    payeeVpa,
+    payeeJid,
+    payerJid
+} = {}) => {
+    if (!reminderId) {
+        throw new TypeError('buildPaymentReminder needs a reminderId');
+    }
+    return drop({
+        reminderId: String(reminderId),
+        instanceId: instanceId === undefined ? undefined : String(instanceId),
+        description,
+        frequency,
+        status,
+        amount: amount === undefined ? undefined : (0, money)(amount, currency),
+        payeeVpa,
+        payeeJid,
+        payerJid
+    });
+};
+
+const readSplitPayment = (msg) => {
+    const message = msg?.message ?? msg;
+    const split = message?.splitPaymentMessage;
+    if (!split) {
+        return null;
+    }
+    return drop({
+        splitId: split.splitId,
+        total: (0, readMoney)(split.totalAmount),
+        description: split.description,
+        requesterJid: split.requesterJid,
+        createdAtMs: split.createdAtMs === undefined ? undefined : Number(split.createdAtMs),
+        participants: (split.participants ?? []).map(participant => drop({
+            jid: participant.jid,
+            amount: (0, readMoney)(participant.amount),
+            status: participant.status
+        }))
+    });
+};
+
+const readPaymentReminder = (msg) => {
+    const message = msg?.message ?? msg;
+    const reminder = message?.paymentReminderMessage;
+    if (!reminder) {
+        return null;
+    }
+    return drop({
+        reminderId: reminder.reminderId,
+        instanceId: reminder.instanceId,
+        description: reminder.description,
+        frequency: reminder.frequency,
+        status: reminder.status,
+        amount: (0, readMoney)(reminder.amount),
+        payeeVpa: reminder.payeeVpa,
+        payeeJid: reminder.payeeJid,
+        payerJid: reminder.payerJid
+    });
+};
+
+export { SplitPaymentStatus, ReminderFrequency, ReminderStatus, MONEY_OFFSET, money, readMoney, buildSplitPayment, buildSplitPaymentUpdate, buildPaymentReminder, readSplitPayment, readPaymentReminder };

package/lib/Utils/scheduled-message.d.ts

@@ -0,0 +1,82 @@
+import { proto } from "../../WAProto";
+export const SCHEDULED_MSG_META_TYPE: "scheduled_message";
+export const SCHEDULED_MSG_MAX_PER_CHAT: 30;
+export const SCHEDULED_MSG_MAX_MEDIA: 1;
+export const SCHEDULED_MSG_RESOURCE_LIMIT_NACK_CODE: 419;
+export const SCHEDULED_MSG_REVEAL_KEY_BYTES: 32;
+export const SCHEDULED_MSG_REVEAL_KEY_IV_BYTES: 12;
+export const SCHEDULED_MSG_REVEAL_KEY_RETENTION_DAYS: 30;
+export const SCHEDULED_MSG_TAG_BYTES: 16;
+export const SCHEDULED_MSG_WINDOW: {
+    readonly chat: {
+        readonly minSeconds: 600;
+        readonly maxSeconds: 1209600;
+    };
+    readonly newsletter: {
+        readonly minSeconds: 600;
+        readonly maxSeconds: 2592000;
+    };
+};
+export const generateRevealKey: () => Buffer;
+export const generateRevealKeyId: () => string;
+export const encryptWithRevealKey: (plaintext: any, revealKey: any) => {
+    encIv: Buffer;
+    encPayload: Buffer;
+};
+export const decryptWithRevealKey: (encPayload: any, encIv: any, revealKey: any) => Buffer;
+export const buildConditionalRevealMessage: ({ encPayload, encIv, revealKeyId }: {
+    encPayload: any;
+    encIv: any;
+    revealKeyId: any;
+}) => {
+    conditionalRevealMessage: {
+        conditionalRevealMessageType: proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType;
+        encPayload: Buffer;
+        encIv: Buffer;
+        revealKeyId: any;
+    };
+};
+export const encodeScheduledMessage: (message: any, revealKey?: Buffer) => {
+    revealKey: Buffer;
+    revealKeyId: string;
+    encIv: Buffer;
+    encPayload: Buffer;
+    message: {
+        conditionalRevealMessage: {
+            conditionalRevealMessageType: proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType;
+            encPayload: Buffer;
+            encIv: Buffer;
+            revealKeyId: any;
+        };
+    };
+};
+export const decodeScheduledMessage: (conditionalRevealMessage: any, revealKey: any) => proto.Message;
+export const buildScheduledMsgMetaNode: ({ kind, scheduledTimestampS, revealKeyId, revealKey }: {
+    kind?: string | undefined;
+    scheduledTimestampS?: any;
+    revealKeyId: any;
+    revealKey: any;
+}) => {
+    tag: string;
+    attrs: {
+        type: string;
+        st?: string;
+    };
+    content: {
+        tag: string;
+        attrs: {
+            rkid: any;
+        };
+        content: Buffer | undefined;
+    }[];
+};
+export const buildUnscheduleProtocolMessage: (key: any) => {
+    protocolMessage: {
+        key: any;
+        type: proto.Message.ProtocolMessage.Type;
+    };
+};
+export const isScheduledTimeValid: (scheduledTimestampS: any, nowSeconds?: number, window?: {
+    readonly minSeconds: 600;
+    readonly maxSeconds: 1209600;
+}) => boolean;

package/lib/Utils/scheduled-message.js

@@ -0,0 +1,113 @@
+import * as crypto_1 from 'crypto';
+import * as WAProto_1 from '../../WAProto/index.js';
+const SCHEDULED_MSG_META_TYPE = 'scheduled_message';
+const SCHEDULED_MSG_MAX_PER_CHAT = 30;
+const SCHEDULED_MSG_MAX_MEDIA = 1;
+const SCHEDULED_MSG_RESOURCE_LIMIT_NACK_CODE = 419;
+const SCHEDULED_MSG_REVEAL_KEY_BYTES = 32;
+const SCHEDULED_MSG_REVEAL_KEY_IV_BYTES = 12;
+const SCHEDULED_MSG_REVEAL_KEY_RETENTION_DAYS = 30;
+const SCHEDULED_MSG_TAG_BYTES = 16;
+
+const SCHEDULED_MSG_WINDOW = Object.freeze({
+    chat: { minSeconds: 600, maxSeconds: 1209600 },
+    newsletter: { minSeconds: 600, maxSeconds: 2592000 }
+});
+
+const generateRevealKey = () => (0, crypto_1.randomBytes)(SCHEDULED_MSG_REVEAL_KEY_BYTES);
+
+const generateRevealKeyId = () => (0, crypto_1.randomUUID)();
+
+const encryptWithRevealKey = (plaintext, revealKey) => {
+    const key = Buffer.from(revealKey);
+    if (key.length !== SCHEDULED_MSG_REVEAL_KEY_BYTES) {
+        throw new TypeError(`reveal key must be ${SCHEDULED_MSG_REVEAL_KEY_BYTES} bytes`);
+    }
+    const encIv = (0, crypto_1.randomBytes)(SCHEDULED_MSG_REVEAL_KEY_IV_BYTES);
+    const cipher = (0, crypto_1.createCipheriv)('aes-256-gcm', key, encIv);
+    const body = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()]);
+    return { encIv, encPayload: Buffer.concat([body, cipher.getAuthTag()]) };
+};
+
+const decryptWithRevealKey = (encPayload, encIv, revealKey) => {
+    const key = Buffer.from(revealKey);
+    const payload = Buffer.from(encPayload);
+    if (payload.length < SCHEDULED_MSG_TAG_BYTES) {
+        throw new TypeError('encrypted payload is too short to carry an auth tag');
+    }
+    const decipher = (0, crypto_1.createDecipheriv)('aes-256-gcm', key, Buffer.from(encIv));
+    decipher.setAuthTag(payload.subarray(payload.length - SCHEDULED_MSG_TAG_BYTES));
+    return Buffer.concat([
+        decipher.update(payload.subarray(0, payload.length - SCHEDULED_MSG_TAG_BYTES)),
+        decipher.final()
+    ]);
+};
+
+const buildConditionalRevealMessage = ({ encPayload, encIv, revealKeyId }) => ({
+    conditionalRevealMessage: {
+        conditionalRevealMessageType: WAProto_1.proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType.SCHEDULED_MESSAGE,
+        encPayload: Buffer.from(encPayload),
+        encIv: Buffer.from(encIv),
+        revealKeyId
+    }
+});
+
+const encodeScheduledMessage = (message, revealKey = (0, generateRevealKey)()) => {
+    const plaintext = WAProto_1.proto.Message.encode(WAProto_1.proto.Message.fromObject(message)).finish();
+    const { encIv, encPayload } = (0, encryptWithRevealKey)(plaintext, revealKey);
+    const revealKeyId = (0, generateRevealKeyId)();
+    return {
+        revealKey,
+        revealKeyId,
+        encIv,
+        encPayload,
+        message: (0, buildConditionalRevealMessage)({ encPayload, encIv, revealKeyId })
+    };
+};
+
+const decodeScheduledMessage = (conditionalRevealMessage, revealKey) => {
+    const inner = conditionalRevealMessage?.conditionalRevealMessage ?? conditionalRevealMessage;
+    if (!inner?.encPayload || !inner?.encIv) {
+        throw new TypeError('conditionalRevealMessage is missing encPayload or encIv');
+    }
+    return WAProto_1.proto.Message.decode((0, decryptWithRevealKey)(inner.encPayload, inner.encIv, revealKey));
+};
+
+const buildScheduledMsgMetaNode = ({ kind = 'schedule', scheduledTimestampS, revealKeyId, revealKey }) => {
+    if (!revealKeyId) {
+        throw new TypeError('revealKeyId is required');
+    }
+    if (kind === 'schedule' && !revealKey) {
+        throw new TypeError('scheduling requires the reveal key');
+    }
+    const attrs = { type: SCHEDULED_MSG_META_TYPE };
+    if (kind === 'schedule') {
+        if (!Number.isFinite(Number(scheduledTimestampS))) {
+            throw new TypeError('scheduledTimestampS must be a unix timestamp in seconds');
+        }
+        attrs.st = String(Math.floor(Number(scheduledTimestampS)));
+    }
+    return {
+        tag: 'meta',
+        attrs,
+        content: [{
+            tag: 'key',
+            attrs: { rkid: revealKeyId },
+            content: kind === 'schedule' ? Buffer.from(revealKey) : undefined
+        }]
+    };
+};
+
+const buildUnscheduleProtocolMessage = (key) => ({
+    protocolMessage: {
+        key,
+        type: WAProto_1.proto.Message.ProtocolMessage.Type.MESSAGE_UNSCHEDULE
+    }
+});
+
+const isScheduledTimeValid = (scheduledTimestampS, nowSeconds = Math.floor(Date.now() / 1000), window = SCHEDULED_MSG_WINDOW.chat) => {
+    const rounded = Math.floor(nowSeconds / 60) * 60;
+    return scheduledTimestampS - rounded >= window.minSeconds && scheduledTimestampS - nowSeconds <= window.maxSeconds;
+};
+
+export { SCHEDULED_MSG_META_TYPE, SCHEDULED_MSG_MAX_PER_CHAT, SCHEDULED_MSG_MAX_MEDIA, SCHEDULED_MSG_RESOURCE_LIMIT_NACK_CODE, SCHEDULED_MSG_REVEAL_KEY_BYTES, SCHEDULED_MSG_REVEAL_KEY_IV_BYTES, SCHEDULED_MSG_REVEAL_KEY_RETENTION_DAYS, SCHEDULED_MSG_TAG_BYTES, SCHEDULED_MSG_WINDOW, generateRevealKey, generateRevealKeyId, encryptWithRevealKey, decryptWithRevealKey, buildConditionalRevealMessage, encodeScheduledMessage, decodeScheduledMessage, buildScheduledMsgMetaNode, buildUnscheduleProtocolMessage, isScheduledTimeValid };

package/lib/Utils/status-stickers.d.ts

@@ -0,0 +1,78 @@
+import { proto } from "../../WAProto";
+export const StatusLinkType: {
+    readonly RASTERIZED_LINK_PREVIEW: 1;
+    readonly RASTERIZED_LINK_TRUNCATED: 2;
+    readonly RASTERIZED_LINK_FULL_URL: 3;
+};
+export const STICKER_DEFAULT_AREA: {
+    readonly x: 0.25;
+    readonly y: 0.4;
+    readonly width: 0.5;
+    readonly height: 0.2;
+};
+export const stickerArea: ({ x, y, width, height }?: {
+    x?: number | undefined;
+    y?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+}) => {
+    x: number;
+    y: number;
+}[];
+export const locationSticker: ({ latitude, longitude, name, area, skipConfirmation }?: {
+    latitude?: any;
+    longitude?: any;
+    name?: any;
+    area?: any;
+    skipConfirmation?: any;
+}) => any;
+export const channelSticker: ({ jid, name, serverMessageId, accessibilityText, area }?: {
+    jid?: any;
+    name?: any;
+    serverMessageId?: number | undefined;
+    accessibilityText?: any;
+    area?: any;
+}) => any;
+export const linkSticker: ({ url, title, area, linkType }?: {
+    url?: any;
+    title?: any;
+    area?: any;
+    linkType?: number | undefined;
+}) => any;
+export const musicSticker: ({ songId, title, author, mediaId, artworkDirectPath, artworkSha256, artworkEncSha256, artworkMediaKey, artistAttribution, countryBlocklist, isExplicit, startTimeMs, derivedStartTimeMs, durationMs, area }?: {
+    songId?: any;
+    title?: any;
+    author?: any;
+    mediaId?: any;
+    artworkDirectPath?: any;
+    artworkSha256?: any;
+    artworkEncSha256?: any;
+    artworkMediaKey?: any;
+    artistAttribution?: any;
+    countryBlocklist?: any;
+    isExplicit?: any;
+    startTimeMs?: number | undefined;
+    derivedStartTimeMs?: any;
+    durationMs?: any;
+    area?: any;
+}) => any;
+export const messageSticker: ({ stanzaId, message, area }?: {
+    stanzaId?: any;
+    message?: any;
+    area?: any;
+}) => any;
+export const normalizeStickers: (stickers: any) => proto.InteractiveAnnotation[];
+export const readStickers: (message: any) => any[];
+export const MusicMessageStyle: {
+    readonly UNKNOWN: 0;
+    readonly VINYL: 1;
+};
+export const MUSIC_ALLOWED_HOSTS: readonly string[];
+export const isMusicHostAllowed: (value: any) => boolean;
+export const buildMusicMessage: ({ songUri, artworkUri, style, contextInfo, ...music }?: {
+    songUri?: any;
+    artworkUri?: any;
+    style?: number | undefined;
+    contextInfo?: any;
+}) => any;
+export const readMusicMessage: (msg: any) => any;