Page MenuHomePhabricator
Differential D11774

[lib] introduce createOrUpdateFarcasterChannelTagActionTypes
ClosedPublic
Actions

Authored by ginsu on Apr 24 2024, 11:32 PM.
Tags
None
Referenced Files
Unknown Object (File)
Mar 12 2025, 6:11 AM
Unknown Object (File)
Mar 7 2025, 12:11 PM
Unknown Object (File)
Mar 2 2025, 9:44 AM
Unknown Object (File)
Feb 21 2025, 7:26 PM
Unknown Object (File)
Jan 28 2025, 8:37 PM
Unknown Object (File)
Jan 28 2025, 8:37 PM
Unknown Object (File)
Jan 28 2025, 8:37 PM
Unknown Object (File)
Jan 28 2025, 8:36 PM
View All 70 Files
Subscribers
ashoat
tomek

Details

Reviewers
bartek
atul
tomek
Commits
rCOMM46cdf8d6b793: [lib] introduce createOrUpdateFarcasterChannelTagActionTypes
Summary

This diff introduces the createOrUpdateFarcasterChannelTagActionTypes so that we can dispatch this action from the client and is another necessary piece we need to properly call the create_or_update_farcaster_channel_tag endpoint

Linear task: https://linear.app/comm/issue/ENG-7801/introduce-create-or-update-farcaster-channel-tag-action

Depends on D11773

Test Plan

Locally I was able to confirm that when I dispatchted this new action I would call the create_or_update_farcaster_channel_tag endpoint

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

ginsu created this revision.Apr 24 2024, 11:32 PM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptApr 24 2024, 11:32 PM
ginsu edited the summary of this revision. (Show Details)Apr 24 2024, 11:33 PM
ginsu added reviewers: bartek, atul, tomek.
ginsu added a parent revision: D11773: [keyserver] introduce create_or_update_farcaster_channel_tag endpoint.
ginsu added a child revision: D11775: [lib] introduce useCreateOrUpdateFarcasterChannelTag.Apr 24 2024, 11:43 PM
Harbormaster completed remote builds in B28458: Diff 39475.Apr 24 2024, 11:48 PM
ginsu requested review of this revision.Apr 24 2024, 11:48 PM
tomek accepted this revision.Apr 25 2024, 7:00 AM
This revision is now accepted and ready to land.Apr 25 2024, 7:00 AM
ginsu updated this revision to Diff 39664.Apr 29 2024, 11:47 AM

rebase before landing

This revision was landed with ongoing or failed builds.Apr 29 2024, 11:57 AM
Closed by commit rCOMM46cdf8d6b793: [lib] introduce createOrUpdateFarcasterChannelTagActionTypes (authored by ginsu). · Explain Why
This revision was automatically updated to reflect the committed changes.
ginsu added a commit: rCOMM46cdf8d6b793: [lib] introduce createOrUpdateFarcasterChannelTagActionTypes.
Harbormaster completed remote builds in B28584: Diff 39664.Apr 29 2024, 12:04 PM

Revision Contents
Changeset List

PathSize
lib/
actions/
7 lines
types/
22 lines

Diff 39671

View Options

lib/actions/community-actions.js

// @flow // @flow
import { getConfig } from './config.js';
import { olmSessionErrors } from './olm-utils.js';
import { type AuthMetadata } from '../shared/identity-client-context.js';
import type { TunnelbrokerClientMessageToDevice } from '../tunnelbroker/tunnelbroker-context.js';
import {
outboundP2PMessageStatuses,
type OutboundP2PMessage,
} from '../types/sqlite-types.js';
import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
function getClientMessageIDFromTunnelbrokerMessageID( function getClientMessageIDFromTunnelbrokerMessageID(
tunnelbrokerMessageID: string, tunnelbrokerMessageID: string,
): string { ): string {
const ids = tunnelbrokerMessageID.split('#'); const ids = tunnelbrokerMessageID.split('#');
if (ids.length !== 2) { if (ids.length !== 2) {
throw new Error('Invalid tunnelbrokerMessageID'); throw new Error('Invalid tunnelbrokerMessageID');
} }
return ids[1]; return ids[1];
} }
export { getClientMessageIDFromTunnelbrokerMessageID }; async function sendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure'> {
const { sqliteAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return 'failure';
}
try {
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
},
encryptedData: JSON.parse(message.ciphertext),
};
await sendMessage(
{
deviceID: message.deviceID,
payload: JSON.stringify(encryptedMessage),
},
message.messageID,
);
await sqliteAPI.markOutboundP2PMessageAsSent(
message.messageID,
message.deviceID,
);
return 'success';
} catch (e) {
console.error(e);
return 'failure';
}
}
async function encryptAndSendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure' | 'missing_session'> {
const { olmAPI } = getConfig();
try {
const result = await olmAPI.encryptAndPersist(
message.plaintext,
message.deviceID,
message.messageID,
);
const encryptedMessage: OutboundP2PMessage = {
...message,
ciphertext: JSON.stringify(result),
};
return await sendMessageToPeer(encryptedMessage, authMetadata, sendMessage);
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return 'missing_session';
}
console.log(`Error sending messages to peer ${message.deviceID}`, e);
return 'failure';
}
}
export type HandleOutboundP2PMessageResult = {
+status: 'success' | 'failure' | 'missing_session',
+messageID: string,
};
async function handleOutboundP2PMessage(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<HandleOutboundP2PMessageResult> {
if (message.status === outboundP2PMessageStatuses.persisted) {
const status = await encryptAndSendMessageToPeer(
message,
authMetadata,
sendMessage,
);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.encrypted) {
const status = await sendMessageToPeer(message, authMetadata, sendMessage);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.sent) {
// Handle edge-case when message was sent, but it wasn't updated
// in the message store.
return {
status: 'success',
messageID: message.messageID,
};
}
return {
status: 'failure',
messageID: message.messageID,
};
}
export type EphemeralEncryptAndSendMessageToPeerResult = {
+status: 'success' | 'failure' | 'missing_session',
+recipient: { +userID: string, +deviceID: string },
};
async function ephemeralEncryptAndSendMessageToPeer(
contentPayload: string,
recipient: { +userID: string, +deviceID: string },
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<EphemeralEncryptAndSendMessageToPeerResult> {
const { olmAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return { status: 'failure', recipient };
}
const senderInfo = {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
};
try {
const encryptedData = await olmAPI.encrypt(
contentPayload,
recipient.deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo,
encryptedData,
};
await sendMessage({
deviceID: recipient.deviceID,
payload: JSON.stringify(encryptedMessage),
});
return { status: 'success', recipient };
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return { status: 'missing_session', recipient };
}
console.log(`Error sending messages to peer ${recipient.deviceID}`, e);
return { status: 'failure', recipient };
}
}
export {
getClientMessageIDFromTunnelbrokerMessageID,
sendMessageToPeer,
encryptAndSendMessageToPeer,
ephemeralEncryptAndSendMessageToPeer,
handleOutboundP2PMessage,
};
View Options

lib/types/redux-types.js

// @flow // @flow
import { getConfig } from './config.js';
import { olmSessionErrors } from './olm-utils.js';
import { type AuthMetadata } from '../shared/identity-client-context.js';
import type { TunnelbrokerClientMessageToDevice } from '../tunnelbroker/tunnelbroker-context.js';
import {
outboundP2PMessageStatuses,
type OutboundP2PMessage,
} from '../types/sqlite-types.js';
import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
function getClientMessageIDFromTunnelbrokerMessageID( function getClientMessageIDFromTunnelbrokerMessageID(
tunnelbrokerMessageID: string, tunnelbrokerMessageID: string,
): string { ): string {
const ids = tunnelbrokerMessageID.split('#'); const ids = tunnelbrokerMessageID.split('#');
if (ids.length !== 2) { if (ids.length !== 2) {
throw new Error('Invalid tunnelbrokerMessageID'); throw new Error('Invalid tunnelbrokerMessageID');
} }
return ids[1]; return ids[1];
} }
export { getClientMessageIDFromTunnelbrokerMessageID }; async function sendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure'> {
const { sqliteAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return 'failure';
}
try {
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
},
encryptedData: JSON.parse(message.ciphertext),
};
await sendMessage(
{
deviceID: message.deviceID,
payload: JSON.stringify(encryptedMessage),
},
message.messageID,
);
await sqliteAPI.markOutboundP2PMessageAsSent(
message.messageID,
message.deviceID,
);
return 'success';
} catch (e) {
console.error(e);
return 'failure';
}
}
async function encryptAndSendMessageToPeer(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<'success' | 'failure' | 'missing_session'> {
const { olmAPI } = getConfig();
try {
const result = await olmAPI.encryptAndPersist(
message.plaintext,
message.deviceID,
message.messageID,
);
const encryptedMessage: OutboundP2PMessage = {
...message,
ciphertext: JSON.stringify(result),
};
return await sendMessageToPeer(encryptedMessage, authMetadata, sendMessage);
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return 'missing_session';
}
console.log(`Error sending messages to peer ${message.deviceID}`, e);
return 'failure';
}
}
export type HandleOutboundP2PMessageResult = {
+status: 'success' | 'failure' | 'missing_session',
+messageID: string,
};
async function handleOutboundP2PMessage(
message: OutboundP2PMessage,
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<HandleOutboundP2PMessageResult> {
if (message.status === outboundP2PMessageStatuses.persisted) {
const status = await encryptAndSendMessageToPeer(
message,
authMetadata,
sendMessage,
);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.encrypted) {
const status = await sendMessageToPeer(message, authMetadata, sendMessage);
return {
status,
messageID: message.messageID,
};
} else if (message.status === outboundP2PMessageStatuses.sent) {
// Handle edge-case when message was sent, but it wasn't updated
// in the message store.
return {
status: 'success',
messageID: message.messageID,
};
}
return {
status: 'failure',
messageID: message.messageID,
};
}
export type EphemeralEncryptAndSendMessageToPeerResult = {
+status: 'success' | 'failure' | 'missing_session',
+recipient: { +userID: string, +deviceID: string },
};
async function ephemeralEncryptAndSendMessageToPeer(
contentPayload: string,
recipient: { +userID: string, +deviceID: string },
authMetadata: ?AuthMetadata,
sendMessage: (
message: TunnelbrokerClientMessageToDevice,
messageID: ?string,
) => Promise<void>,
): Promise<EphemeralEncryptAndSendMessageToPeerResult> {
const { olmAPI } = getConfig();
if (!authMetadata || !authMetadata.deviceID || !authMetadata.userID) {
return { status: 'failure', recipient };
}
const senderInfo = {
deviceID: authMetadata.deviceID,
userID: authMetadata.userID,
};
try {
const encryptedData = await olmAPI.encrypt(
contentPayload,
recipient.deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo,
encryptedData,
};
await sendMessage({
deviceID: recipient.deviceID,
payload: JSON.stringify(encryptedMessage),
});
return { status: 'success', recipient };
} catch (e) {
if (e.message?.includes(olmSessionErrors.sessionDoesNotExist)) {
return { status: 'missing_session', recipient };
}
console.log(`Error sending messages to peer ${recipient.deviceID}`, e);
return { status: 'failure', recipient };
}
}
export {
getClientMessageIDFromTunnelbrokerMessageID,
sendMessageToPeer,
encryptAndSendMessageToPeer,
ephemeralEncryptAndSendMessageToPeer,
handleOutboundP2PMessage,
};