edge-core-js 2.45.0 → 2.46.1

package/lib/flow/fake-types.js

@@ -1,187 +0,0 @@
-// @flow
-
-import type { Cleaner } from "cleaners";
-import {
-  asArray,
-  asDate,
-  asNumber,
-  asObject,
-  asOptional,
-  asString,
-  asValue,
-  uncleaner,
-} from "cleaners";
-
-import {
-  asBase32,
-  asBase64,
-  asEdgeBox,
-  asEdgeKeyBox,
-  asEdgeSnrp,
-  asRecovery2Auth,
-} from "./server-cleaners";
-import type { EdgeBox, EdgeKeyBox, EdgeSnrp } from "./server-types";
-
-export type EdgeRepoDump = {
-  [key: string]: EdgeBox;
-}
-
-export type EdgeVoucherDump = {
-  // Identity:
-  loginId: Uint8Array;
-  voucherAuth: Uint8Array;
-  voucherId: string;
-
-  // Login capability:
-  created: Date;
-  activates: Date; // Automatically becomes approved on this date
-  status: "pending" | "approved" | "rejected";
-
-  // Information about the login:
-  ip: string;
-  ipDescription: string;
-  deviceDescription: string | void;
-}
-
-export type EdgeLoginDump = {
-  // Identity:
-  appId: string;
-  created: Date;
-  loginId: Uint8Array;
-
-  // Nested logins:
-  parentBox?: EdgeBox;
-  parentId?: Uint8Array; // loginId
-
-  // 2-factor login:
-  otpKey?: Uint8Array;
-  otpResetAuth?: string;
-  otpResetDate?: Date;
-  otpTimeout?: number;
-
-  // Password login:
-  passwordAuth?: Uint8Array;
-  passwordAuthBox?: EdgeBox;
-  passwordAuthSnrp?: EdgeSnrp;
-  passwordBox?: EdgeBox;
-  passwordKeySnrp?: EdgeSnrp;
-
-  // PIN v2 login:
-  pin2Id?: Uint8Array; // base64
-  pin2Auth?: Uint8Array;
-  pin2Box?: EdgeBox;
-  pin2KeyBox?: EdgeBox;
-  pin2TextBox?: EdgeBox;
-
-  // Recovery v2 login:
-  recovery2Id?: Uint8Array; // base64
-  recovery2Auth?: Uint8Array[];
-  recovery2Box?: EdgeBox;
-  recovery2KeyBox?: EdgeBox;
-  question2Box?: EdgeBox;
-
-  // Secret-key login:
-  loginAuth?: Uint8Array;
-  loginAuthBox?: EdgeBox;
-
-  // Username:
-  userId?: Uint8Array;
-  userTextBox?: EdgeBox;
-
-  // Resources:
-  children: EdgeLoginDump[];
-  keyBoxes: EdgeKeyBox[];
-  mnemonicBox?: EdgeBox;
-  rootKeyBox?: EdgeBox;
-  syncKeyBox?: EdgeBox;
-  vouchers: EdgeVoucherDump[];
-
-  // Obsolete:
-  pinBox?: EdgeBox;
-  pinId?: string;
-  pinKeyBox?: EdgeBox;
-}
-
-export const asEdgeRepoDump: Cleaner<EdgeRepoDump> = asObject(asEdgeBox);
-
-export const asEdgeVoucherDump: Cleaner<EdgeVoucherDump> = asObject({
-  // Identity:
-  loginId: asBase64,
-  voucherAuth: asBase64,
-  voucherId: asString,
-
-  // Login capability:
-  created: asDate,
-  activates: asDate, // Automatically becomes approved on this date
-  status: asValue("pending", "approved", "rejected"),
-
-  // Information about the login:
-  ip: asString,
-  ipDescription: asString,
-  deviceDescription: asOptional(asString),
-});
-
-export const asEdgeLoginDump: Cleaner<EdgeLoginDump> = asObject({
-  // Identity:
-  appId: asString,
-  created: asOptional(asDate, () => new Date()),
-  loginId: asBase64,
-
-  // Nested logins:
-  children: asOptional(
-    asArray((raw) => asEdgeLoginDump(raw)),
-    () => [],
-  ),
-  parentBox: asOptional(asEdgeBox),
-  parentId: (): Uint8Array | void => undefined,
-
-  // 2-factor login:
-  otpKey: asOptional(asBase32),
-  otpResetAuth: asOptional(asString),
-  otpResetDate: asOptional(asDate),
-  otpTimeout: asOptional(asNumber),
-
-  // Password login:
-  passwordAuth: asOptional(asBase64),
-  passwordAuthBox: asOptional(asEdgeBox),
-  passwordAuthSnrp: asOptional(asEdgeSnrp),
-  passwordBox: asOptional(asEdgeBox),
-  passwordKeySnrp: asOptional(asEdgeSnrp),
-
-  // PIN v2 login:
-  pin2Id: asOptional(asBase64),
-  pin2Auth: asOptional(asBase64),
-  pin2Box: asOptional(asEdgeBox),
-  pin2KeyBox: asOptional(asEdgeBox),
-  pin2TextBox: asOptional(asEdgeBox),
-
-  // Recovery v2 login:
-  recovery2Id: asOptional(asBase64),
-  recovery2Auth: asOptional(asRecovery2Auth),
-  question2Box: asOptional(asEdgeBox),
-  recovery2Box: asOptional(asEdgeBox),
-  recovery2KeyBox: asOptional(asEdgeBox),
-
-  // Secret-key login:
-  loginAuth: asOptional(asBase64),
-  loginAuthBox: asOptional(asEdgeBox),
-
-  // Username:
-  userId: asOptional(asBase64),
-  userTextBox: asOptional(asEdgeBox),
-
-  // Keys and assorted goodies:
-  keyBoxes: asOptional(asArray(asEdgeKeyBox), () => []),
-  mnemonicBox: asOptional(asEdgeBox),
-  rootKeyBox: asOptional(asEdgeBox),
-  syncKeyBox: asOptional(asEdgeBox),
-  vouchers: asOptional(asArray(asEdgeVoucherDump), () => []),
-
-  // Obsolete:
-  pinBox: asOptional(asEdgeBox),
-  pinId: asOptional(asString),
-  pinKeyBox: asOptional(asEdgeBox),
-});
-
-export const wasEdgeLoginDump = uncleaner<EdgeLoginDump>(asEdgeLoginDump);
-export const wasEdgeRepoDump = uncleaner<EdgeRepoDump>(asEdgeRepoDump);

package/lib/flow/server-cleaners.js

@@ -1,444 +0,0 @@
-// @flow
-
-import type { Cleaner } from "cleaners";
-import {
-  asArray,
-  asBoolean,
-  asCodec,
-  asDate,
-  asEither,
-  asNumber,
-  asObject,
-  asOptional,
-  asString,
-  asUnknown,
-  asValue,
-  uncleaner,
-} from "cleaners";
-import { base16, base32, base64 } from "rfc4648";
-
-import type {
-  ChallengeErrorPayload,
-  ChangeOtpPayload,
-  ChangePasswordPayload,
-  ChangePin2IdPayload,
-  ChangePin2Payload,
-  ChangeRecovery2IdPayload,
-  ChangeRecovery2Payload,
-  ChangeSecretPayload,
-  ChangeUsernamePayload,
-  ChangeVouchersPayload,
-  CreateChallengePayload,
-  CreateKeysPayload,
-  CreateLoginPayload,
-  EdgeBox,
-  EdgeKeyBox,
-  EdgeLobbyReply,
-  EdgeLobbyRequest,
-  EdgeSnrp,
-  LobbyPayload,
-  LoginPayload,
-  LoginRequestBody,
-  LoginResponseBody,
-  MessagesPayload,
-  OtpErrorPayload,
-  OtpResetPayload,
-  PasswordErrorPayload,
-  Recovery2InfoPayload,
-  UsernameInfoPayload,
-} from "./server-types";
-import type { EdgePendingVoucher } from "./types";
-
-/**
- * A string of hex-encoded binary data.
- */
-export const asBase16: Cleaner<Uint8Array> = asCodec(
-  (raw) => base16.parse(asString(raw)),
-  (clean) => base16.stringify(clean).toLowerCase(),
-);
-
-/**
- * A string of base32-encoded binary data.
- */
-export const asBase32: Cleaner<Uint8Array> = asCodec(
-  (raw) => base32.parse(asString(raw), { loose: true }),
-  (clean) => base32.stringify(clean, { pad: false }),
-);
-
-/**
- * A string of base64-encoded binary data.
- */
-export const asBase64: Cleaner<Uint8Array> = asCodec(
-  (raw) => base64.parse(asString(raw)),
-  (clean) => base64.stringify(clean),
-);
-
-// ---------------------------------------------------------------------
-// public Edge types
-// ---------------------------------------------------------------------
-
-export const asEdgePendingVoucher: Cleaner<EdgePendingVoucher> = asObject({
-  voucherId: asString,
-  activates: asDate,
-  created: asDate,
-  ip: asString,
-  ipDescription: asString,
-  deviceDescription: asOptional(asString),
-});
-
-// ---------------------------------------------------------------------
-// internal Edge types
-// ---------------------------------------------------------------------
-
-export const asEdgeBox: Cleaner<EdgeBox> = asObject({
-  encryptionType: asNumber,
-  data_base64: asBase64,
-  iv_hex: asBase16,
-});
-
-export const asEdgeKeyBox: Cleaner<EdgeKeyBox> = asObject({
-  created: asOptional(asDate),
-  data_base64: asBase64,
-  encryptionType: asNumber,
-  iv_hex: asBase16,
-});
-
-export const asEdgeSnrp: Cleaner<EdgeSnrp> = asObject({
-  salt_hex: asBase16,
-  n: asNumber,
-  r: asNumber,
-  p: asNumber,
-});
-
-export const asEdgeLobbyRequest: Cleaner<EdgeLobbyRequest> = asObject({
-  loginRequest: asOptional(asObject({ appId: asString }).withRest),
-  publicKey: asBase64,
-  timeout: asOptional(asNumber),
-}).withRest;
-
-export const asEdgeLobbyReply: Cleaner<EdgeLobbyReply> = asObject({
-  publicKey: asBase64,
-  box: asEdgeBox,
-});
-
-/**
- * An array of base64-encoded hashed recovery answers.
- */
-export const asRecovery2Auth: Cleaner<Uint8Array[]> = asArray(asBase64);
-
-// ---------------------------------------------------------------------
-// top-level request & response bodies
-// ---------------------------------------------------------------------
-
-export const asLoginRequestBody: Cleaner<LoginRequestBody> = asObject({
-  // The request payload:
-  data: asUnknown,
-
-  // Common fields for all login methods:
-  challengeId: asOptional(asString),
-  deviceDescription: asOptional(asString),
-  otp: asOptional(asString),
-  syncToken: asOptional(asString),
-  voucherId: asOptional(asString),
-  voucherAuth: asOptional(asBase64),
-
-  // Secret-key login:
-  loginId: asOptional(asBase64),
-  loginAuth: asOptional(asBase64),
-
-  // Password login:
-  userId: asOptional(asBase64),
-  passwordAuth: asOptional(asBase64),
-
-  // PIN login:
-  pin2Id: asOptional(asBase64),
-  pin2Auth: asOptional(asBase64),
-
-  // Recovery login:
-  recovery2Id: asOptional(asBase64),
-  recovery2Auth: asOptional(asRecovery2Auth),
-
-  // Messages:
-  loginIds: asOptional(asArray(asBase64)),
-
-  // OTP reset:
-  otpResetAuth: asOptional(asString),
-
-  // Legacy:
-  did: asOptional(asString),
-  l1: asOptional(asBase64),
-  lp1: asOptional(asBase64),
-  lpin1: asOptional(asBase64),
-  lra1: asOptional(asBase64),
-  recoveryAuth: asOptional(asBase64), // lra1
-});
-
-export const asLoginResponseBody: Cleaner<LoginResponseBody> = asObject({
-  // The response payload:
-  results: asOptional(asUnknown),
-
-  // What type of response is this (success or failure)?:
-  status_code: asNumber,
-  message: asString,
-});
-
-// ---------------------------------------------------------------------
-// request payloads
-// ---------------------------------------------------------------------
-
-export const asChangeOtpPayload: Cleaner<ChangeOtpPayload> = asObject({
-  otpTimeout: asOptional(asNumber, 7 * 24 * 60 * 60), // seconds
-  otpKey: asBase32,
-});
-
-export const asChangePasswordPayload: Cleaner<ChangePasswordPayload> = asObject(
-  {
-    passwordAuth: asBase64,
-    passwordAuthBox: asEdgeBox,
-    passwordAuthSnrp: asEdgeSnrp,
-    passwordBox: asEdgeBox,
-    passwordKeySnrp: asEdgeSnrp,
-  },
-);
-
-export const asChangePin2IdPayload: Cleaner<ChangePin2IdPayload> = asObject({
-  pin2Id: asBase64,
-});
-
-export const asChangePin2Payload: Cleaner<ChangePin2Payload> = asObject({
-  pin2Id: asOptional(asBase64),
-  pin2Auth: asOptional(asBase64),
-  pin2Box: asOptional(asEdgeBox),
-  pin2KeyBox: asOptional(asEdgeBox),
-  pin2TextBox: asEdgeBox,
-});
-
-export const asChangeRecovery2IdPayload: Cleaner<ChangeRecovery2IdPayload> =
-  asObject({
-    recovery2Id: asBase64,
-  });
-
-export const asChangeRecovery2Payload: Cleaner<ChangeRecovery2Payload> =
-  asObject({
-    recovery2Id: asBase64,
-    recovery2Auth: asRecovery2Auth,
-    recovery2Box: asEdgeBox,
-    recovery2KeyBox: asEdgeBox,
-    question2Box: asEdgeBox,
-  });
-
-export const asChangeSecretPayload: Cleaner<ChangeSecretPayload> = asObject({
-  loginAuthBox: asEdgeBox,
-  loginAuth: asBase64,
-});
-
-export const asChangeUsernamePayload: Cleaner<ChangeUsernamePayload> = asObject(
-  {
-    userId: asBase64,
-    userTextBox: asEdgeBox,
-  },
-);
-
-export const asChangeVouchersPayload: Cleaner<ChangeVouchersPayload> = asObject(
-  {
-    approvedVouchers: asOptional(asArray(asString)),
-    rejectedVouchers: asOptional(asArray(asString)),
-  },
-);
-
-export const asCreateKeysPayload: Cleaner<CreateKeysPayload> = asObject({
-  allowExisting: asOptional(asBoolean, false),
-  keyBoxes: asArray(asEdgeBox),
-  newSyncKeys: asOptional(asArray(asString), () => []),
-});
-
-export const asCreateLoginPayload: Cleaner<CreateLoginPayload> = asObject({
-  appId: asString,
-  loginId: asBase64,
-  parentBox: asOptional(asEdgeBox),
-});
-
-// ---------------------------------------------------------------------
-// response payloads
-// ---------------------------------------------------------------------
-
-export const asChallengeErrorPayload: Cleaner<ChallengeErrorPayload> = asObject(
-  {
-    challengeId: asString,
-    challengeUri: asString,
-  },
-);
-
-export const asCreateChallengePayload: Cleaner<CreateChallengePayload> =
-  asObject({
-    challengeId: asString,
-    challengeUri: asOptional(asString),
-  });
-
-export const asLobbyPayload: Cleaner<LobbyPayload> = asObject({
-  request: asEdgeLobbyRequest,
-  replies: asArray(asEdgeLobbyReply),
-});
-
-const asTrue = asValue(true);
-
-export const asLoginPayload: Cleaner<LoginPayload> = asObject({
-  // Identity:
-  appId: asString,
-  created: asDate,
-  loginId: asBase64,
-  syncToken: asOptional(asString),
-
-  // Nested logins:
-  children: asOptional(asArray((raw) => asLoginPayload(raw))),
-  parentBox: asOptional(asEdgeBox),
-
-  // 2-factor login:
-  otpKey: asOptional(asEither(asTrue, asBase32)),
-  otpResetDate: asOptional(asDate),
-  otpTimeout: asOptional(asNumber),
-
-  // Password login:
-  passwordAuthBox: asOptional(asEdgeBox),
-  passwordAuthSnrp: asOptional(asEdgeSnrp),
-  passwordBox: asOptional(asEither(asTrue, asEdgeBox)),
-  passwordKeySnrp: asOptional(asEdgeSnrp),
-
-  // PIN v2 login:
-  pin2Box: asOptional(asEither(asTrue, asEdgeBox)),
-  pin2KeyBox: asOptional(asEdgeBox),
-  pin2TextBox: asOptional(asEdgeBox),
-
-  // Recovery v2 login:
-  question2Box: asOptional(asEdgeBox),
-  recovery2Box: asOptional(asEither(asTrue, asEdgeBox)),
-  recovery2KeyBox: asOptional(asEdgeBox),
-
-  // Secret-key login:
-  loginAuthBox: asOptional(asEdgeBox),
-
-  // Username:
-  userId: asOptional(asBase64),
-  userTextBox: asOptional(asEdgeBox),
-
-  // Voucher login:
-  pendingVouchers: asOptional(asArray(asEdgePendingVoucher), () => []),
-
-  // Resources:
-  keyBoxes: asOptional(asArray(asEdgeKeyBox)),
-  mnemonicBox: asOptional(asEdgeBox),
-  rootKeyBox: asOptional(asEdgeBox),
-  syncKeyBox: asOptional(asEdgeBox),
-});
-
-export const asMessagesPayload: Cleaner<MessagesPayload> = asArray(
-  asObject({
-    loginId: asBase64,
-    otpResetPending: asOptional(asBoolean, false),
-    pendingVouchers: asOptional(asArray(asEdgePendingVoucher), () => []),
-    recovery2Corrupt: asOptional(asBoolean, false),
-  }),
-);
-
-export const asOtpErrorPayload: Cleaner<OtpErrorPayload> = asObject({
-  login_id: asOptional(asBase64),
-  otp_reset_auth: asOptional(asString),
-  otp_timeout_date: asOptional(asDate),
-  reason: asOptional(asValue("ip", "otp"), "otp"),
-  voucher_activates: asOptional(asDate),
-  voucher_auth: asOptional(asBase64),
-  voucher_id: asOptional(asString),
-});
-
-export const asOtpResetPayload: Cleaner<OtpResetPayload> = asObject({
-  otpResetDate: asDate,
-});
-
-export const asPasswordErrorPayload: Cleaner<PasswordErrorPayload> = asObject({
-  wait_seconds: asOptional(asNumber),
-});
-
-export const asRecovery2InfoPayload: Cleaner<Recovery2InfoPayload> = asObject({
-  question2Box: asEdgeBox,
-});
-
-export const asUsernameInfoPayload: Cleaner<UsernameInfoPayload> = asObject({
-  loginId: asBase64,
-
-  // Password login:
-  passwordAuthSnrp: asOptional(asEdgeSnrp),
-
-  // Recovery v1 login:
-  questionBox: asOptional(asEdgeBox),
-  questionKeySnrp: asOptional(asEdgeSnrp),
-  recoveryAuthSnrp: asOptional(asEdgeSnrp),
-});
-
-// ---------------------------------------------------------------------
-// uncleaners
-// ---------------------------------------------------------------------
-
-// Common types:
-export const wasEdgeBox = uncleaner<EdgeBox>(asEdgeBox);
-export const wasEdgeLobbyReply = uncleaner<EdgeLobbyReply>(asEdgeLobbyReply);
-export const wasEdgeLobbyRequest =
-  uncleaner<EdgeLobbyRequest>(asEdgeLobbyRequest);
-
-// Top-level request / response bodies:
-export const wasLoginRequestBody =
-  uncleaner<LoginRequestBody>(asLoginRequestBody);
-export const wasLoginResponseBody =
-  uncleaner<LoginResponseBody>(asLoginResponseBody);
-
-// Request payloads:
-export const wasChangeOtpPayload =
-  uncleaner<ChangeOtpPayload>(asChangeOtpPayload);
-export const wasChangePasswordPayload = uncleaner<ChangePasswordPayload>(
-  asChangePasswordPayload,
-);
-export const wasChangePin2IdPayload = uncleaner<ChangePin2IdPayload>(
-  asChangePin2IdPayload,
-);
-export const wasChangePin2Payload =
-  uncleaner<ChangePin2Payload>(asChangePin2Payload);
-export const wasChangeRecovery2IdPayload = uncleaner<ChangeRecovery2IdPayload>(
-  asChangeRecovery2IdPayload,
-);
-export const wasChangeRecovery2Payload = uncleaner<ChangeRecovery2Payload>(
-  asChangeRecovery2Payload,
-);
-export const wasChangeSecretPayload = uncleaner<ChangeSecretPayload>(
-  asChangeSecretPayload,
-);
-export const wasChangeUsernamePayload = uncleaner<ChangeUsernamePayload>(
-  asChangeUsernamePayload,
-);
-export const wasChangeVouchersPayload = uncleaner<ChangeVouchersPayload>(
-  asChangeVouchersPayload,
-);
-export const wasCreateKeysPayload =
-  uncleaner<CreateKeysPayload>(asCreateKeysPayload);
-export const wasCreateLoginPayload =
-  uncleaner<CreateLoginPayload>(asCreateLoginPayload);
-
-// Response payloads:
-export const wasChallengeErrorPayload = uncleaner<ChallengeErrorPayload>(
-  asChallengeErrorPayload,
-);
-export const wasCreateChallengePayload = uncleaner<CreateChallengePayload>(
-  asCreateChallengePayload,
-);
-export const wasLobbyPayload = uncleaner<LobbyPayload>(asLobbyPayload);
-export const wasLoginPayload = uncleaner<LoginPayload>(asLoginPayload);
-export const wasMessagesPayload = uncleaner<MessagesPayload>(asMessagesPayload);
-export const wasOtpErrorPayload = uncleaner<OtpErrorPayload>(asOtpErrorPayload);
-export const wasOtpResetPayload = uncleaner<OtpResetPayload>(asOtpResetPayload);
-export const wasPasswordErrorPayload = uncleaner<PasswordErrorPayload>(
-  asPasswordErrorPayload,
-);
-export const wasRecovery2InfoPayload = uncleaner<Recovery2InfoPayload>(
-  asRecovery2InfoPayload,
-);
-export const wasUsernameInfoPayload = uncleaner<UsernameInfoPayload>(
-  asUsernameInfoPayload,
-);