Page MenuHomePhabricator
Differential D13718

[lib] change fetchFarcasterChannelByName -> fetchFarcasterChannelByID and refactor
ClosedPublic
Actions

Authored by varun on Oct 15 2024, 12:44 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 11, 6:38 AM
Unknown Object (File)
Mon, Mar 3, 2:45 PM
Unknown Object (File)
Mon, Mar 3, 12:59 PM
Unknown Object (File)
Mon, Mar 3, 10:20 AM
Unknown Object (File)
Mon, Mar 3, 10:19 AM
Unknown Object (File)
Mon, Mar 3, 6:19 AM
Unknown Object (File)
Fri, Feb 28, 2:09 AM
Unknown Object (File)
Fri, Feb 28, 1:40 AM
View All 88 Files
Subscribers
tomek

Details

Reviewers
ashoat
Commits
rCOMM64617bd18d7d: [lib] change fetchFarcasterChannelByName -> fetchFarcasterChannelByID and…
Summary

realized we're conflating channel name and ID in our code. this change cleans things up a little and makes sure we're querying by ID

Depends on D13695

Test Plan

called fetchFarcasterChannelByID with a channel name ("Crypto Fantasy League") and didn't get back a response. called it again with a channel ID ("fantasyisland") and got the right response

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

varun created this revision.Oct 15 2024, 12:44 PM
Herald added a subscriber: tomek. · View Herald TranscriptOct 15 2024, 12:44 PM
varun published this revision for review.Oct 15 2024, 12:46 PM

I see D13717 was landed already but I think this diff is still an improvement. Will rebase and wait for CI before landing

varun added inline comments.Oct 15 2024, 12:48 PM
lib/utils/neynar-client.js
152 ↗(On Diff #45207)

Even though we only call this function from fetchFarcasterChannelByID, I think it's a useful change. we may want to query by name in the future and both types of queries use the same underlying neynar api

Harbormaster completed remote builds in B32255: Diff 45207.Oct 15 2024, 1:02 PM
ashoat requested changes to this revision.Oct 15 2024, 2:00 PM

Glad you independently found the id/name bug!

I don't think we need support for fetching by name right now. Can you simplify this to just a rename?

lib/utils/neynar-client.js
152 ↗(On Diff #45207)

I think this is overengineering. I don't think it's worth having this complexity in the codebase for a hypothetical future use case. We can always introduce it later when we determine that use case is needed. In general, this approach of building for hypothetical cases hurts readability and bloats the codebase, increasing the amount of maintenance required

This revision now requires changes to proceed.Oct 15 2024, 2:00 PM
varun updated this revision to Diff 45214.Oct 15 2024, 9:43 PM

change to just a rename

varun added a child revision: D13722: [lib] split up useResolvedAvatar.Oct 15 2024, 9:46 PM
Harbormaster completed remote builds in B32262: Diff 45214.Oct 15 2024, 10:02 PM
ashoat accepted this revision.Oct 16 2024, 9:13 PM
This revision is now accepted and ready to land.Oct 16 2024, 9:13 PM
Closed by commit rCOMM64617bd18d7d: [lib] change fetchFarcasterChannelByName -> fetchFarcasterChannelByID and… (authored by varun). · Explain WhyOct 17 2024, 4:47 AM
This revision was automatically updated to reflect the committed changes.
varun added a commit: rCOMM64617bd18d7d: [lib] change fetchFarcasterChannelByName -> fetchFarcasterChannelByID and….

Revision Contents
Changeset List

PathSize
keyserver/
src/
updaters/
2 lines
lib/
utils/
17 lines
native/
community-settings/
tag-farcaster-channel/
2 lines
web/
tag-farcaster-channel/
2 lines

Diff 45247

View Options

keyserver/src/updaters/thread-updaters.js

// @flow // @flow
import { requireNativeModule } from 'expo-modules-core'; import { requireNativeModule } from 'expo-modules-core';
import invariant from 'invariant'; import invariant from 'invariant';
const KEY_SIZE = 32; // bytes const KEY_SIZE = 32; // bytes
const IV_LENGTH = 12; // bytes, IV - unique Initialization Vector (nonce) const IV_LENGTH = 12; // bytes, IV - unique Initialization Vector (nonce)
const TAG_LENGTH = 16; // bytes - GCM auth tag const TAG_LENGTH = 16; // bytes - GCM auth tag
const AESCryptoModule: { const AESCryptoModule: {
+generateKey: (destination: Uint8Array) => void, +generateKey: (destination: Uint8Array) => void,
+generateIV: (destination: Uint8Array) => void,
+encrypt: ( +encrypt: (
key: Uint8Array, key: Uint8Array,
data: Uint8Array, data: Uint8Array,
destination: Uint8Array, destination: Uint8Array,
initializationVector: Uint8Array,
) => void, ) => void,
+decrypt: ( +decrypt: (
key: Uint8Array, key: Uint8Array,
data: Uint8Array, data: Uint8Array,
destination: Uint8Array, destination: Uint8Array,
) => void, ) => void,
} = requireNativeModule('AESCrypto'); } = requireNativeModule('AESCrypto');
export function generateKey(): Uint8Array { export function generateKey(): Uint8Array {
const keyBuffer = new Uint8Array(KEY_SIZE); const keyBuffer = new Uint8Array(KEY_SIZE);
AESCryptoModule.generateKey(keyBuffer); AESCryptoModule.generateKey(keyBuffer);
return keyBuffer; return keyBuffer;
} }
export function encrypt(key: Uint8Array, data: Uint8Array): Uint8Array { export function generateIV(): Uint8Array {
const ivBuffer = new Uint8Array(IV_LENGTH);
AESCryptoModule.generateIV(ivBuffer);
return ivBuffer;
}
export function encrypt(
key: Uint8Array,
data: Uint8Array,
initializationVector?: ?Uint8Array,
): Uint8Array {
const sealedDataBuffer = new Uint8Array(data.length + IV_LENGTH + TAG_LENGTH); const sealedDataBuffer = new Uint8Array(data.length + IV_LENGTH + TAG_LENGTH);
AESCryptoModule.encrypt(key, data, sealedDataBuffer); const iv = initializationVector ?? new Uint8Array(0);
AESCryptoModule.encrypt(key, data, sealedDataBuffer, iv);
return sealedDataBuffer; return sealedDataBuffer;
} }
export function decrypt(key: Uint8Array, data: Uint8Array): Uint8Array { export function decrypt(key: Uint8Array, data: Uint8Array): Uint8Array {
invariant(data.length >= IV_LENGTH + TAG_LENGTH, 'Invalid data length'); invariant(data.length >= IV_LENGTH + TAG_LENGTH, 'Invalid data length');
const plaintextBuffer = new Uint8Array(data.length - IV_LENGTH - TAG_LENGTH); const plaintextBuffer = new Uint8Array(data.length - IV_LENGTH - TAG_LENGTH);
AESCryptoModule.decrypt(key, data, plaintextBuffer); AESCryptoModule.decrypt(key, data, plaintextBuffer);
return plaintextBuffer; return plaintextBuffer;
} }
View Options

lib/utils/neynar-client.js

// @flow // @flow
import { requireNativeModule } from 'expo-modules-core'; import { requireNativeModule } from 'expo-modules-core';
import invariant from 'invariant'; import invariant from 'invariant';
const KEY_SIZE = 32; // bytes const KEY_SIZE = 32; // bytes
const IV_LENGTH = 12; // bytes, IV - unique Initialization Vector (nonce) const IV_LENGTH = 12; // bytes, IV - unique Initialization Vector (nonce)
const TAG_LENGTH = 16; // bytes - GCM auth tag const TAG_LENGTH = 16; // bytes - GCM auth tag
const AESCryptoModule: { const AESCryptoModule: {
+generateKey: (destination: Uint8Array) => void, +generateKey: (destination: Uint8Array) => void,
+generateIV: (destination: Uint8Array) => void,
+encrypt: ( +encrypt: (
key: Uint8Array, key: Uint8Array,
data: Uint8Array, data: Uint8Array,
destination: Uint8Array, destination: Uint8Array,
initializationVector: Uint8Array,
) => void, ) => void,
+decrypt: ( +decrypt: (
key: Uint8Array, key: Uint8Array,
data: Uint8Array, data: Uint8Array,
destination: Uint8Array, destination: Uint8Array,
) => void, ) => void,
} = requireNativeModule('AESCrypto'); } = requireNativeModule('AESCrypto');
export function generateKey(): Uint8Array { export function generateKey(): Uint8Array {
const keyBuffer = new Uint8Array(KEY_SIZE); const keyBuffer = new Uint8Array(KEY_SIZE);
AESCryptoModule.generateKey(keyBuffer); AESCryptoModule.generateKey(keyBuffer);
return keyBuffer; return keyBuffer;
} }
export function encrypt(key: Uint8Array, data: Uint8Array): Uint8Array { export function generateIV(): Uint8Array {
const ivBuffer = new Uint8Array(IV_LENGTH);
AESCryptoModule.generateIV(ivBuffer);
return ivBuffer;
}
export function encrypt(
key: Uint8Array,
data: Uint8Array,
initializationVector?: ?Uint8Array,
): Uint8Array {
const sealedDataBuffer = new Uint8Array(data.length + IV_LENGTH + TAG_LENGTH); const sealedDataBuffer = new Uint8Array(data.length + IV_LENGTH + TAG_LENGTH);
AESCryptoModule.encrypt(key, data, sealedDataBuffer); const iv = initializationVector ?? new Uint8Array(0);
AESCryptoModule.encrypt(key, data, sealedDataBuffer, iv);
return sealedDataBuffer; return sealedDataBuffer;
} }
export function decrypt(key: Uint8Array, data: Uint8Array): Uint8Array { export function decrypt(key: Uint8Array, data: Uint8Array): Uint8Array {
invariant(data.length >= IV_LENGTH + TAG_LENGTH, 'Invalid data length'); invariant(data.length >= IV_LENGTH + TAG_LENGTH, 'Invalid data length');
const plaintextBuffer = new Uint8Array(data.length - IV_LENGTH - TAG_LENGTH); const plaintextBuffer = new Uint8Array(data.length - IV_LENGTH - TAG_LENGTH);
AESCryptoModule.decrypt(key, data, plaintextBuffer); AESCryptoModule.decrypt(key, data, plaintextBuffer);
return plaintextBuffer; return plaintextBuffer;
} }
View Options

native/community-settings/tag-farcaster-channel/tag-farcaster-channel-by-name.react.js

// @flow // @flow
import { requireNativeModule } from 'expo-modules-core'; import { requireNativeModule } from 'expo-modules-core';
import invariant from 'invariant'; import invariant from 'invariant';
const KEY_SIZE = 32; // bytes const KEY_SIZE = 32; // bytes
const IV_LENGTH = 12; // bytes, IV - unique Initialization Vector (nonce) const IV_LENGTH = 12; // bytes, IV - unique Initialization Vector (nonce)
const TAG_LENGTH = 16; // bytes - GCM auth tag const TAG_LENGTH = 16; // bytes - GCM auth tag
const AESCryptoModule: { const AESCryptoModule: {
+generateKey: (destination: Uint8Array) => void, +generateKey: (destination: Uint8Array) => void,
+generateIV: (destination: Uint8Array) => void,
+encrypt: ( +encrypt: (
key: Uint8Array, key: Uint8Array,
data: Uint8Array, data: Uint8Array,
destination: Uint8Array, destination: Uint8Array,
initializationVector: Uint8Array,
) => void, ) => void,
+decrypt: ( +decrypt: (
key: Uint8Array, key: Uint8Array,
data: Uint8Array, data: Uint8Array,
destination: Uint8Array, destination: Uint8Array,
) => void, ) => void,
} = requireNativeModule('AESCrypto'); } = requireNativeModule('AESCrypto');
export function generateKey(): Uint8Array { export function generateKey(): Uint8Array {
const keyBuffer = new Uint8Array(KEY_SIZE); const keyBuffer = new Uint8Array(KEY_SIZE);
AESCryptoModule.generateKey(keyBuffer); AESCryptoModule.generateKey(keyBuffer);
return keyBuffer; return keyBuffer;
} }
export function encrypt(key: Uint8Array, data: Uint8Array): Uint8Array { export function generateIV(): Uint8Array {
const ivBuffer = new Uint8Array(IV_LENGTH);
AESCryptoModule.generateIV(ivBuffer);
return ivBuffer;
}
export function encrypt(
key: Uint8Array,
data: Uint8Array,
initializationVector?: ?Uint8Array,
): Uint8Array {
const sealedDataBuffer = new Uint8Array(data.length + IV_LENGTH + TAG_LENGTH); const sealedDataBuffer = new Uint8Array(data.length + IV_LENGTH + TAG_LENGTH);
AESCryptoModule.encrypt(key, data, sealedDataBuffer); const iv = initializationVector ?? new Uint8Array(0);
AESCryptoModule.encrypt(key, data, sealedDataBuffer, iv);
return sealedDataBuffer; return sealedDataBuffer;
} }
export function decrypt(key: Uint8Array, data: Uint8Array): Uint8Array { export function decrypt(key: Uint8Array, data: Uint8Array): Uint8Array {
invariant(data.length >= IV_LENGTH + TAG_LENGTH, 'Invalid data length'); invariant(data.length >= IV_LENGTH + TAG_LENGTH, 'Invalid data length');
const plaintextBuffer = new Uint8Array(data.length - IV_LENGTH - TAG_LENGTH); const plaintextBuffer = new Uint8Array(data.length - IV_LENGTH - TAG_LENGTH);
AESCryptoModule.decrypt(key, data, plaintextBuffer); AESCryptoModule.decrypt(key, data, plaintextBuffer);
return plaintextBuffer; return plaintextBuffer;
} }
View Options

web/tag-farcaster-channel/create-farcaster-channel-tag-modal.react.js

// @flow // @flow
import { requireNativeModule } from 'expo-modules-core'; import { requireNativeModule } from 'expo-modules-core';
import invariant from 'invariant'; import invariant from 'invariant';
const KEY_SIZE = 32; // bytes const KEY_SIZE = 32; // bytes
const IV_LENGTH = 12; // bytes, IV - unique Initialization Vector (nonce) const IV_LENGTH = 12; // bytes, IV - unique Initialization Vector (nonce)
const TAG_LENGTH = 16; // bytes - GCM auth tag const TAG_LENGTH = 16; // bytes - GCM auth tag
const AESCryptoModule: { const AESCryptoModule: {
+generateKey: (destination: Uint8Array) => void, +generateKey: (destination: Uint8Array) => void,
+generateIV: (destination: Uint8Array) => void,
+encrypt: ( +encrypt: (
key: Uint8Array, key: Uint8Array,
data: Uint8Array, data: Uint8Array,
destination: Uint8Array, destination: Uint8Array,
initializationVector: Uint8Array,
) => void, ) => void,
+decrypt: ( +decrypt: (
key: Uint8Array, key: Uint8Array,
data: Uint8Array, data: Uint8Array,
destination: Uint8Array, destination: Uint8Array,
) => void, ) => void,
} = requireNativeModule('AESCrypto'); } = requireNativeModule('AESCrypto');
export function generateKey(): Uint8Array { export function generateKey(): Uint8Array {
const keyBuffer = new Uint8Array(KEY_SIZE); const keyBuffer = new Uint8Array(KEY_SIZE);
AESCryptoModule.generateKey(keyBuffer); AESCryptoModule.generateKey(keyBuffer);
return keyBuffer; return keyBuffer;
} }
export function encrypt(key: Uint8Array, data: Uint8Array): Uint8Array { export function generateIV(): Uint8Array {
const ivBuffer = new Uint8Array(IV_LENGTH);
AESCryptoModule.generateIV(ivBuffer);
return ivBuffer;
}
export function encrypt(
key: Uint8Array,
data: Uint8Array,
initializationVector?: ?Uint8Array,
): Uint8Array {
const sealedDataBuffer = new Uint8Array(data.length + IV_LENGTH + TAG_LENGTH); const sealedDataBuffer = new Uint8Array(data.length + IV_LENGTH + TAG_LENGTH);
AESCryptoModule.encrypt(key, data, sealedDataBuffer); const iv = initializationVector ?? new Uint8Array(0);
AESCryptoModule.encrypt(key, data, sealedDataBuffer, iv);
return sealedDataBuffer; return sealedDataBuffer;
} }
export function decrypt(key: Uint8Array, data: Uint8Array): Uint8Array { export function decrypt(key: Uint8Array, data: Uint8Array): Uint8Array {
invariant(data.length >= IV_LENGTH + TAG_LENGTH, 'Invalid data length'); invariant(data.length >= IV_LENGTH + TAG_LENGTH, 'Invalid data length');
const plaintextBuffer = new Uint8Array(data.length - IV_LENGTH - TAG_LENGTH); const plaintextBuffer = new Uint8Array(data.length - IV_LENGTH - TAG_LENGTH);
AESCryptoModule.decrypt(key, data, plaintextBuffer); AESCryptoModule.decrypt(key, data, plaintextBuffer);
return plaintextBuffer; return plaintextBuffer;
} }