feat: use new encryption infra to decrypt posts

cspell.json

@@ -352,6 +352,7 @@
         "openocean",
         "OPENOCEAN",
         "pkts",
+        "plusplus",
         "pnpm",
         "poap",
         "poaps",

jest.config.ts

@@ -24,6 +24,7 @@ const config: InitialOptionsTsJest = {
     extensionsToTreatAsEsm: ['.ts', '.tsx'],
     moduleNameMapper: {
         '@masknet/shared-base': '<rootDir>/packages/shared-base/src/index.ts',
+        '@masknet/typed-message/base': '<rootDir>/packages/typed-message/base/index.ts',
         'jest-websocket-mock': '<rootDir>/packages/web3-shared/base/node_modules/jest-websocket-mock',
         'reconnecting-websocket': '<rootDir>/packages/web3-shared/base/node_modules/reconnecting-websocket',
         'date-fns/(.*)': '<rootDir>/packages/web3-shared/base/node_modules/date-fns/$1',

packages/encryption/package.json

@@ -7,6 +7,7 @@
   "dependencies": {
     "@dimensiondev/stego-js": "0.11.1-20201027083223-8ab41be",
     "@masknet/shared-base": "workspace:*",
+    "@masknet/typed-message": "workspace:*",
     "@msgpack/msgpack": "^2.7.0"
   }
 }

packages/encryption/src/encryption/Decryption.ts

@@ -1,11 +1,6 @@
 import { unreachable } from '@dimensiondev/kit'
-import {
-    decodeTypedMessageFromDocument,
-    decodeTypedMessageV38ToV40Format,
-    AESCryptoKey,
-    EC_Public_CryptoKey,
-    andThenAsync,
-} from '@masknet/shared-base'
+import { decodeTypedMessageFromDocument, decodeTypedMessageV38ToV40Format } from '@masknet/typed-message/base'
+import { AESCryptoKey, EC_Public_CryptoKey, andThenAsync } from '@masknet/shared-base'
 import { None, Result } from 'ts-results'
 import { AESAlgorithmEnum, PayloadParseResult } from '../payload'
 import { decryptWithAES, importAESFromJWK } from '../utils'

packages/encryption/src/encryption/DecryptionTypes.ts

@@ -1,5 +1,7 @@
-import type { TypedMessage, ProfileIdentifier, AESCryptoKey, EC_Public_CryptoKey } from '@masknet/shared-base'
+import type { TypedMessage } from '@masknet/typed-message/base'
+import type { ProfileIdentifier, AESCryptoKey, EC_Public_CryptoKey } from '@masknet/shared-base'
 import type { PayloadParseResult } from '../payload'
+import { registerSerializableClass } from '@masknet/shared-base'
 
 export interface DecryptOptions {
     message: PayloadParseResult.Payload
@@ -150,6 +152,7 @@ export enum ErrorReasons {
     // Not used in this library.
     UnrecognizedAuthor = '[@masknet/encryption] No author is recognized which is required for the image steganography decoding.',
     CurrentProfileDoesNotConnectedToPersona = '[@masknet/encryption] Cannot decrypt by E2E because no persona is linked with the current profile.',
+    NoPayloadFound = '[@masknet/encryption] No payload found in this material.',
 }
 export class DecryptError extends Error {
     static Reasons = ErrorReasons
@@ -158,3 +161,18 @@ export class DecryptError extends Error {
         super(message, { cause })
     }
 }
+registerSerializableClass(
+    'MaskDecryptError',
+    (x) => x instanceof DecryptError,
+    (e: DecryptError) => ({
+        cause: (e as any).cause,
+        recoverable: e.recoverable,
+        message: e.message,
+        stack: e.stack,
+    }),
+    (o) => {
+        const e = new DecryptError(o.message, o.cause, o.recoverable)
+        e.stack = o.stack
+        return e
+    },
+)

packages/encryption/src/encryption/Encryption.ts

@@ -1,14 +1,14 @@
 import type {
     PersonaIdentifier,
     ProfileIdentifier,
-    TypedMessage,
     AESCryptoKey,
     PostIVIdentifier,
     EC_Public_CryptoKey,
     EC_Private_CryptoKey,
     ECKeyIdentifier,
     IdentifierMap,
 } from '@masknet/shared-base'
+import type { TypedMessage } from '@masknet/typed-message/base'
 
 export interface EncryptOptions {
     /** Payload version to use. */

packages/encryption/src/image-steganography/index.ts

@@ -93,7 +93,7 @@ export async function steganographyEncodeImage(buf: ArrayBuffer, options: Encode
 
 export type DecodeImageOptions = SteganographyIO & Partial<EncodeOptions> & Pick<EncodeOptions, 'pass'>
 
-async function steganographyDecodeImage(buf: ArrayBuffer, options: DecodeImageOptions) {
+async function inner(buf: ArrayBuffer, options: DecodeImageOptions) {
     const dimension = getDimension(buf)
     const preset = dimensionPreset.find((d) => isSameDimension(d, dimension))
     if (!preset) return ''
@@ -104,6 +104,6 @@ async function steganographyDecodeImage(buf: ArrayBuffer, options: DecodeImageOp
     })
 }
 
-export async function steganographyDecodeImageUrl(url: string, options: DecodeImageOptions) {
-    return steganographyDecodeImage(await options.downloadImage(url), options)
+export async function steganographyDecodeImage(image: Blob | string, options: DecodeImageOptions) {
+    return inner(typeof image === 'string' ? await options.downloadImage(image) : await image.arrayBuffer(), options)
 }

packages/encryption/src/index.ts

@@ -37,7 +37,7 @@ export {
     type EncodeImageOptions,
     type ImageTemplateTypes,
     type SteganographyIO,
-    steganographyDecodeImageUrl,
+    steganographyDecodeImage,
     steganographyEncodeImage,
     GrayscaleAlgorithm,
 } from './image-steganography'

packages/encryption/src/payload/types.ts

@@ -116,12 +116,14 @@ export enum AESAlgorithmEnum {
     A256GCM = 'A256GCM',
 }
 export enum SocialNetworkEnum {
+    Unknown = -1,
     Facebook = 0,
     Twitter = 1,
     Instagram = 2,
     Minds = 3,
 }
 const SocialNetworkEnumToDomain: Record<SocialNetworkEnum, string> = {
+    [SocialNetworkEnum.Unknown]: 'localhost',
     [SocialNetworkEnum.Facebook]: 'facebook.com',
     [SocialNetworkEnum.Minds]: 'minds.com',
     [SocialNetworkEnum.Twitter]: 'twitter.com',

packages/encryption/src/social-network-encode-decode/index.ts

@@ -1,10 +1,14 @@
-import { Some } from 'ts-results'
 import { SocialNetworkEnum } from '../payload/types'
 import { TwitterDecoder, __TwitterEncoder } from './twitter'
 
-export function socialNetworkDecoder(network: SocialNetworkEnum, content: string) {
-    if (network === SocialNetworkEnum.Twitter) return TwitterDecoder(content)
-    return Some(content)
+export function socialNetworkDecoder(network: SocialNetworkEnum, content: string): string[] {
+    if (network === SocialNetworkEnum.Twitter)
+        return TwitterDecoder(content)
+            .map((x) => [x])
+            .unwrapOr([])
+    const all = content.match(/(\u{1F3BC}[\w+/=|]+:\|\|)/giu)
+    if (all) return all
+    return []
 }
 export function socialNetworkEncoder(network: SocialNetworkEnum, content: string) {
     if (network === SocialNetworkEnum.Twitter) return __TwitterEncoder(content)

packages/encryption/tsconfig.json

@@ -7,5 +7,5 @@
     "stripInternal": true
   },
   "include": ["./src/**/*"],
-  "references": [{ "path": "../shared-base" }]
+  "references": [{ "path": "../shared-base" }, { "path": "../typed-message/base" }]
 }

packages/gun-utils/README.md

@@ -0,0 +1,13 @@
+# @masknet/gun-utils
+
+This packages wrap Gun with a developer-friendly API. Before using, please make sure you have understand:
+
+- Gun is a decentralized graph database.
+- There're many other applications are using Gun.
+- Every change is visible to others (may not be correct, but in our use cases it is).
+- There is no "private server", you cannot create a fresh "gun" world that only contains our data.
+- DO NOT publish sensitive information on Gun.
+
+For more information, please access https://gun.eco/.
+
+It is especially important to understand how Gun is modeling "Array of data".

packages/gun-utils/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@masknet/gun-utils",
+  "private": true,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "dependencies": {
+    "event-iterator": "^2.0.0",
+    "gun": "^0.2020.1234"
+  }
+}

packages/gun-utils/src/index.ts

@@ -0,0 +1 @@
+export { deleteGunData, getGunData, pushToGunDataArray, setGunData, subscribeGunMapData } from './utils'

packages/gun-utils/src/instance.ts

@@ -0,0 +1,48 @@
+import Gun from 'gun'
+import 'gun/sea'
+import 'gun/lib/radix'
+import 'gun/lib/radisk'
+import 'gun/lib/store'
+import 'gun/lib/rindexed'
+import { gunServers } from './server'
+
+export type GunRoot = ReturnType<typeof createGun>
+let gun: GunRoot | undefined
+export function getGunInstance(): GunRoot {
+    if (gun) return gun
+    return (gun = createGun())
+}
+
+function createGun() {
+    class WebSocket extends globalThis.WebSocket {
+        constructor(url: string | URL) {
+            super(url)
+            const abort = (this.abort = () => {
+                gun = undefined
+                this.close()
+                console.log('[Network/gun] WebSocket of the Gun instance is killed due to inactive.')
+            })
+            const tick = (this.tick = () => {
+                if (this.timer) clearTimeout(this.timer)
+                this.timer = setTimeout(abort, 15 * 60 * 1000)
+            })
+            this.addEventListener('message', tick, {})
+        }
+        private declare abort: () => void
+        private declare tick: () => void
+        declare timer: NodeJS.Timer | undefined
+        override send(data: any) {
+            this.tick()
+            super.send(data)
+        }
+    }
+
+    const _ = new Gun({
+        peers: [...gunServers],
+        localStorage: false,
+        radisk: true,
+        WebSocket,
+    })
+    _.opt({ retry: Number.POSITIVE_INFINITY })
+    return _
+}

packages/gun-utils/src/utils.ts

@@ -0,0 +1,80 @@
+import { EventIterator } from 'event-iterator'
+import { getGunInstance } from './instance'
+
+function getGunNodeFromPath(path: string[]) {
+    const resultNode = path.reduce((gun, path) => gun.get(path as never), getGunInstance())
+    return resultNode
+}
+/**
+ * Get data from Gun. Equivalent as the following code:
+ *
+ * ```ts
+ * gun.get(path[0]).get(path[1])....get(path[n]).once()
+ * ```
+ */
+export function getGunData(...path: string[]) {
+    return new Promise<{ [x: string]: unknown } | string | number | undefined>((resolve) => {
+        getGunNodeFromPath(path).once(resolve)
+    })
+}
+
+/**
+ * Set data on Gun. Equivalent as the following code:
+ *
+ * ```ts
+ * gun.get(path[0]).get(path[1])....get(path[n]).put(data)
+ * ```
+ * @param path graph path on Gun
+ * @param data data to be stored
+ */
+export function setGunData(path: string[], data: any) {
+    getGunNodeFromPath(path).put(data)
+}
+
+/**
+ * Delete data on Gun. Equivalent as the following code:
+ *
+ * ```ts
+ * gun.get(path[0]).get(path[1])....get(path[n]).put(null!)
+ * ```
+ * @param path graph path on Gun
+ */
+export function deleteGunData(path: string[]) {
+    getGunNodeFromPath(path).put(null!)
+}
+
+/**
+ * Push data to the Gun data Set (Mathematical Set)
+ * @param path graph path on Gun
+ * @param value the object to be stored
+ */
+export function pushToGunDataArray(path: string[], value: object) {
+    getGunNodeFromPath(path).set(value)
+}
+
+/**
+ * Subscribe future data on Gun.
+ * When subscribing a Gun data Set (Mathematical Set), you will not get the immediate result back.
+ *
+ * @param path graph path on Gun
+ * @param isT is the data type T
+ * @param abortSignal the signal to stop subscribing
+ */
+export async function* subscribeGunMapData<T>(path: string[], isT: (x: unknown) => x is T, abortSignal: AbortSignal) {
+    yield* new EventIterator<T>((queue) => {
+        // gun.off() will remove ALL listener on it
+        let listenerClosed = false
+
+        abortSignal.addEventListener('abort', () => {
+            queue.stop()
+            listenerClosed = true
+        })
+
+        const resultNode = getGunNodeFromPath(path)
+
+        resultNode.map().on((data) => {
+            if (listenerClosed) return
+            if (isT(data)) queue.push(data)
+        })
+    })
+}

packages/gun-utils/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src/",
+    "outDir": "./dist/",
+    "tsBuildInfoFile": "./dist/.tsbuildinfo"
+  },
+  "include": ["./src"],
+  "references": []
+}

packages/mask/.webpack/config.ts

@@ -66,9 +66,12 @@ export function createConfiguration(rawFlags: BuildFlags): Configuration {
                     // we can speed up the compile because there is no need to wait tsc build them to the dist folder.
                     '@masknet/dashboard$': require.resolve('../../dashboard/src/entry.tsx'),
                     '@masknet/injected-script': join(__dirname, '../../injected-script/sdk'),
+                    '@masknet/gun-utils': join(__dirname, '../../gun-utils/src/'),
                     '@masknet/shared': join(__dirname, '../../shared/src/'),
                     '@masknet/shared-base': join(__dirname, '../../shared-base/src/'),
                     '@masknet/theme': join(__dirname, '../../theme/src/'),
+                    '@masknet/typed-message/base': join(__dirname, '../../typed-message/base/'),
+                    '@masknet/typed-message/dom': join(__dirname, '../../typed-message/dom/'),
                     '@masknet/icons': join(__dirname, '../../icons/index.ts'),
                     '@masknet/web3-kit': join(__dirname, '../../web3-kit/src/'),
                     '@masknet/web3-providers': join(__dirname, '../../web3-providers/src'),