edge-core-js 2.41.2 → 2.42.0

package/lib/node/index.js

@@ -3135,6 +3135,20 @@ function syncStorageWallet(ai, walletId) {
   });
 }
 
+async function makeEdgeResult(promise) {
+  try {
+    return {
+      ok: true,
+      result: await promise
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error
+    };
+  }
+}
+
 function getStorageWalletLastChanges(state, walletId) {
   return state.storageWallets[walletId].lastChanges;
 }
@@ -3494,30 +3508,6 @@ const upgradeTxNetworkFees = tx => {
   }
 };
 
-function makeStorageWalletApi(ai, walletInfo) {
-  const {
-    id,
-    type,
-    keys
-  } = walletInfo;
-  return {
-    // Broken-out key info:
-    id,
-    type,
-    keys,
-    // Folders:
-    get disklet() {
-      return getStorageWalletDisklet(ai.props.state, id);
-    },
-    get localDisklet() {
-      return getStorageWalletLocalDisklet(ai.props.state, id);
-    },
-    async sync() {
-      await syncStorageWallet(ai, id);
-    }
-  };
-}
-
 function getCurrencyMultiplier(currencyInfo, allTokens, currencyCode) {
   for (const denomination of currencyInfo.denominations) {
     if (denomination.name === currencyCode) {
@@ -3555,484 +3545,440 @@ function waitForCurrencyWallet(ai, walletId) {
   return out;
 }
 
-const TYPED_ARRAYS = {
-  '[object Float32Array]': true,
-  '[object Float64Array]': true,
-  '[object Int16Array]': true,
-  '[object Int32Array]': true,
-  '[object Int8Array]': true,
-  '[object Uint16Array]': true,
-  '[object Uint32Array]': true,
-  '[object Uint8Array]': true,
-  '[object Uint8ClampedArray]': true
-};
-
 /**
- * Compares two objects that are already known to have a common `[[Class]]`.
+ * A key that decrypts a login stash.
  */
-function compareObjects(a, b, type) {
-  // User-created objects:
-  if (type === '[object Object]') {
-    const proto = Object.getPrototypeOf(a);
-    if (proto !== Object.getPrototypeOf(b)) return false;
-    const keys = Object.getOwnPropertyNames(a);
-    if (keys.length !== Object.getOwnPropertyNames(b).length) return false;
 
-    // We know that both objects have the same number of properties,
-    // so if every property in `a` has a matching property in `b`,
-    // the objects must be identical, regardless of key order.
-    for (const key of keys) {
-      if (!Object.prototype.hasOwnProperty.call(b, key) || !compare(a[key], b[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
+/**
+ * The login data decrypted into memory.
+ * @deprecated Use `LoginStash` instead and decrypt it at the point of use.
+ * This is an ongoing refactor to remove this type.
+ */
 
-  // Arrays:
-  if (type === '[object Array]') {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; ++i) {
-      if (!compare(a[i], b[i])) return false;
-    }
-    return true;
-  }
+/**
+ * A stash for a specific child account,
+ * along with its containing tree.
+ */
 
-  // Javascript dates:
-  if (type === '[object Date]') {
-    return a.getTime() === b.getTime();
-  }
-  if (type === '[object Map]') {
-    return compareMap(a, b);
-  }
+const asEdgeWalletInfo = cleaners.asObject({
+  id: cleaners.asString,
+  keys: asJsonObject,
+  type: cleaners.asString
+});
+const wasEdgeWalletInfo = cleaners.uncleaner(asEdgeWalletInfo);
 
-  // Typed arrays:
-  if (TYPED_ARRAYS[type]) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; ++i) {
-      if (a[i] !== b[i]) return false;
-    }
-    return true;
-  }
+/**
+ * Returns the first keyInfo with a matching type.
+ */
+function findFirstKey(keyInfos, type) {
+  return keyInfos.find(info => info.type === type);
+}
+function makeAccountType(appId) {
+  return appId === '' ? 'account-repo:co.airbitz.wallet' : `account-repo:${appId}`;
+}
 
-  // We don't even try comparing anything else:
-  return false;
+/**
+ * Assembles the key metadata structure that is encrypted within a keyBox.
+ * @param idKey Used to derive the wallet id. It's usually `dataKey`.
+ */
+function makeKeyInfo(type, keys, idKey) {
+  const hash = hmacSha256(utf8.parse(type), idKey ?? asEdgeStorageKeys(keys).dataKey);
+  return {
+    id: rfc4648.base64.stringify(hash),
+    type,
+    keys
+  };
 }
 
 /**
- * Compare Maps
+ * Assembles all the resources needed to attach new keys to the account.
+ * @param allowExisting True if the sync keys were derived deterministically,
+ * which implies that duplicate sync keys on the server are not errors,
+ * but leftovers from an earlier failed splitting attempt.
  */
-function compareMap(map1, map2) {
-  if (map1.size !== map2.size) {
-    return false;
+function makeKeysKit(ai, sessionKey, keyInfos, allowExisting = false) {
+  // For crash errors:
+  ai.props.log.breadcrumb('makeKeysKit', {});
+  const {
+    io
+  } = ai.props;
+  const keyBoxes = keyInfos.map(info => ({
+    created: new Date(),
+    ...encrypt(io, utf8.parse(JSON.stringify(wasEdgeWalletInfo(info))), sessionKey.loginKey)
+  }));
+  const newSyncKeys = [];
+  for (const info of keyInfos) {
+    const storageKeys = cleaners.asMaybe(asEdgeStorageKeys)(info.keys);
+    if (storageKeys == null) continue;
+    newSyncKeys.push(rfc4648.base16.stringify(storageKeys.syncKey).toLowerCase());
   }
-  for (const [key, value] of map1) {
-    if (!map2.has(key) || map2.get(key) !== value) {
-      return false;
+  return {
+    loginId: sessionKey.loginId,
+    server: wasCreateKeysPayload({
+      allowExisting,
+      keyBoxes,
+      newSyncKeys
+    }),
+    serverPath: '/v2/login/keys',
+    stash: {
+      keyBoxes
     }
-  }
-  return true;
+  };
 }
+
 /**
- * Returns true if two Javascript values are equal in value.
+ * Flattens an array of key structures, removing duplicates.
  */
-function compare(a, b) {
-  if (a === b) return true;
-
-  // Fast path for primitives:
-  if (typeof a !== 'object') return false;
-  if (typeof b !== 'object') return false;
-
-  // If these are objects, the internal `[[Class]]` properties must match:
-  const type = Object.prototype.toString.call(a);
-  if (type !== Object.prototype.toString.call(b)) return false;
-  return compareObjects(a, b, type);
-}
+function mergeKeyInfos(keyInfos) {
+  const out = [];
+  const ids = new Map(); // Maps ID's to output array indexes
 
-// How often to run jobs from the queue
-let QUEUE_RUN_DELAY = 500;
+  for (const keyInfo of keyInfos) {
+    const {
+      id,
+      keys,
+      type
+    } = keyInfo;
+    if (id == null || rfc4648.base64.parse(id).length !== 32) {
+      throw new Error(`Key integrity violation: invalid id ${id}`);
+    }
+    const index = ids.get(id);
+    if (index != null) {
+      // We have already seen this id, so check for conflicts:
+      const old = out[index];
+      if (old.type !== type) {
+        throw new Error(`Key integrity violation for ${id}: type ${type} does not match ${old.type}`);
+      }
+      for (const key of Object.keys(keys)) {
+        if (old.keys[key] != null && old.keys[key] !== keys[key]) {
+          throw new Error(`Key integrity violation for ${id}: ${key} keys do not match`);
+        }
+      }
 
-// How many jobs to run from the queue on each cycle
-let QUEUE_JOBS_PER_RUN = 3;
-const updateQueue = [];
-function enableTestMode() {
-  QUEUE_JOBS_PER_RUN = 99;
-  QUEUE_RUN_DELAY = 1;
-}
-function pushUpdate(update) {
-  if (updateQueue.length <= 0) {
-    startQueue();
-  }
-  let didUpdate = false;
-  for (const u of updateQueue) {
-    if (u.id === update.id && u.action === update.action) {
-      u.updateFunc = update.updateFunc;
-      didUpdate = true;
-      break;
+      // Do the update:
+      out[index] = {
+        id,
+        keys: {
+          ...old.keys,
+          ...keys
+        },
+        type
+      };
+    } else {
+      // We haven't seen this id, so insert it:
+      ids.set(id, out.length);
+      out.push(keyInfo);
     }
   }
-  if (!didUpdate) {
-    updateQueue.push(update);
-  }
-}
-function startQueue() {
-  setTimeout(() => {
-    const numJobs = Math.min(QUEUE_JOBS_PER_RUN, updateQueue.length);
-    for (let i = 0; i < numJobs; i++) {
-      const u = updateQueue.shift();
-      if (u != null) u.updateFunc();
-    }
-    if (updateQueue.length > 0) {
-      startQueue();
-    }
-  }, QUEUE_RUN_DELAY);
+  return out;
 }
 
 /**
- * Reads a JSON-style object into a JavaScript `Map` object with string keys.
- */
-function asMap(cleaner) {
-  const asJsonObject = cleaners.asObject(cleaner);
-  return cleaners.asCodec(raw => {
-    const clean = asJsonObject(raw);
-    const out = new Map();
-    for (const key of Object.keys(clean)) out.set(key, clean[key]);
-    return out;
-  }, clean => {
-    const out = {};
-    clean.forEach((value, key) => {
-      out[key] = value;
-    });
-    return asJsonObject(out);
-  });
-}
-
-/**
- * Reads a JSON-style object into a JavaScript `Map` object
- * with EdgeTokenId keys.
+ * Decrypts the private keys contained in a login.
  */
-function asTokenIdMap(cleaner) {
-  const asJsonObject = cleaners.asObject(cleaner);
-  return cleaners.asCodec(raw => {
-    const clean = asJsonObject(raw);
-    const out = new Map();
-    for (const key of Object.keys(clean)) {
-      out.set(key === '' ? null : key, clean[key]);
-    }
-    return out;
-  }, clean => {
-    const out = {};
-    clean.forEach((value, key) => {
-      out[key == null ? '' : key] = value;
-    });
-    return asJsonObject(out);
-  });
-}
-
-const asEdgeMetadata = raw => {
-  const clean = asDiskMetadata(raw);
+function decryptKeyInfos(stash, loginKey, keyDates = new Map()) {
   const {
-    exchangeAmount = {}
-  } = clean;
+    appId,
+    keyBoxes = []
+  } = stash;
+  const legacyKeys = [];
 
-  // Delete corrupt amounts that exceed the Javascript number range:
-  for (const fiat of Object.keys(exchangeAmount)) {
-    if (String(exchangeAmount[fiat]).includes('e')) {
-      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-      delete exchangeAmount[fiat];
-    }
-  }
-  return clean;
-};
-function mergeMetadata(under, over) {
-  const out = {
-    exchangeAmount: {}
-  };
+  // BitID wallet:
   const {
-    exchangeAmount = {}
-  } = out;
-
-  // Merge the fiat amounts:
-  const underAmounts = under.exchangeAmount ?? {};
-  const overAmounts = over.exchangeAmount ?? {};
-  for (const fiat of Object.keys(underAmounts)) {
-    if (overAmounts[fiat] !== null) exchangeAmount[fiat] = underAmounts[fiat];
+    mnemonicBox,
+    rootKeyBox
+  } = stash;
+  if (mnemonicBox != null && rootKeyBox != null) {
+    const rootKey = decrypt(rootKeyBox, loginKey);
+    const infoKey = hmacSha256(rootKey, utf8.parse('infoKey'));
+    const keys = {
+      mnemonic: decryptText(mnemonicBox, infoKey),
+      rootKey: rfc4648.base64.stringify(rootKey)
+    };
+    legacyKeys.push(makeKeyInfo('wallet:bitid', keys, rootKey));
   }
-  for (const fiat of Object.keys(overAmounts)) {
-    const amount = overAmounts[fiat];
-    if (amount != null) exchangeAmount[fiat] = amount;
+
+  // Account settings:
+  if (stash.syncKeyBox != null) {
+    const syncKey = decrypt(stash.syncKeyBox, loginKey);
+    const type = makeAccountType(appId);
+    const keys = wasEdgeStorageKeys({
+      dataKey: loginKey,
+      syncKey
+    });
+    legacyKeys.push(makeKeyInfo(type, keys, loginKey));
   }
 
-  // Merge simple fields:
-  if (over.bizId !== null) out.bizId = over.bizId ?? under.bizId;
-  if (over.category !== null) out.category = over.category ?? under.category;
-  if (over.name !== null) out.name = over.name ?? under.name;
-  if (over.notes !== null) out.notes = over.notes ?? under.notes;
-  return out;
+  // Keys:
+  const keyInfos = keyBoxes.map(box => {
+    const keys = asEdgeWalletInfo(JSON.parse(decryptText(box, loginKey)));
+    const created = mergeKeyDate(box.created, keyDates.get(keys.id));
+    if (created != null) keyDates.set(keys.id, created);
+    return keys;
+  });
+  return mergeKeyInfos([...legacyKeys, ...keyInfos]).map(walletInfo => fixWalletInfo(walletInfo));
 }
-const asDiskMetadata = cleaners.asObject({
-  bizId: cleaners.asOptional(cleaners.asNumber),
-  category: cleaners.asOptional(cleaners.asString),
-  exchangeAmount: cleaners.asOptional(cleaners.asObject(cleaners.asNumber)),
-  name: cleaners.asOptional(cleaners.asString),
-  notes: cleaners.asOptional(cleaners.asString)
-});
-
-/**
- * The on-disk transaction format.
- */
 
 /**
- * The Airbitz on-disk transaction format.
+ * Returns all the wallet infos accessible from this login object.
  */
+function decryptAllWalletInfos(stashTree, sessionKey, legacyWalletInfos, walletStates) {
+  // Maps from walletId's to appId's:
+  const dates = new Map();
+  const appIdMap = new Map();
+  const walletInfos = [...legacyWalletInfos];
 
-/**
- * The Airbitz on-disk address format.
- */
+  // Navigate to the starting node:
+  const stash = getChildStash(stashTree, sessionKey.loginId);
 
-/**
- * An on-disk cache to quickly map Airbitz filenames to their dates.
- */
+  // Add the legacy wallets first:
+  for (const info of legacyWalletInfos) {
+    walletInfos.push(info);
+    const appIds = appIdMap.get(info.id);
+    if (appIds != null) appIds.push(stash.appId);else appIdMap.set(info.id, [stash.appId]);
+  }
+  function getAllWalletInfosLoop(stash, loginKey) {
+    // Add our own walletInfos:
+    const keyInfos = decryptKeyInfos(stash, loginKey, dates);
+    for (const info of keyInfos) {
+      walletInfos.push(info);
+      const appIds = appIdMap.get(info.id);
+      if (appIds != null) appIds.push(stash.appId);else appIdMap.set(info.id, [stash.appId]);
+    }
 
-// ---------------------------------------------------------------------
-// building-block cleaners
-// ---------------------------------------------------------------------
-const asEdgeTokenId = cleaners.asEither(cleaners.asString, cleaners.asNull);
-const asFeeRate = cleaners.asValue('high', 'standard', 'low');
-const asEdgeTxSwap = cleaners.asObject({
-  orderId: cleaners.asOptional(cleaners.asString),
-  orderUri: cleaners.asOptional(cleaners.asString),
-  isEstimate: cleaners.asBoolean,
-  // The EdgeSwapInfo from the swap plugin:
-  plugin: cleaners.asObject({
-    pluginId: cleaners.asString,
-    displayName: cleaners.asString,
-    supportEmail: cleaners.asOptional(cleaners.asString)
-  }),
-  // Address information:
-  payoutAddress: cleaners.asString,
-  payoutCurrencyCode: cleaners.asString,
-  payoutTokenId: cleaners.asOptional(asEdgeTokenId),
-  payoutNativeAmount: cleaners.asString,
-  payoutWalletId: cleaners.asString,
-  refundAddress: cleaners.asOptional(cleaners.asString)
-});
-function asIntegerString(raw) {
-  const clean = cleaners.asString(raw);
-  if (!/^\d+$/.test(clean)) {
-    throw new Error('Expected an integer string');
+    // Add our children's walletInfos:
+    for (const child of stash.children ?? []) {
+      if (child.parentBox == null) continue;
+      getAllWalletInfosLoop(child, decrypt(child.parentBox, loginKey));
+    }
   }
-  return clean;
+  getAllWalletInfosLoop(stash, sessionKey.loginKey);
+  return mergeKeyInfos(walletInfos).map(info => {
+    return {
+      appId: getLast(appIdMap.get(info.id) ?? []),
+      appIds: appIdMap.get(info.id) ?? [],
+      // Defaults to be overwritten:
+      archived: false,
+      created: dates.get(info.id),
+      deleted: false,
+      hidden: false,
+      sortIndex: walletInfos.length,
+      // Copy the `imported` field from the raw keys if it exists
+      imported: info.keys.imported,
+      // Actual info:
+      ...walletStates[info.id],
+      ...info
+    };
+  });
 }
 
-// ---------------------------------------------------------------------
-// file cleaners
-// ---------------------------------------------------------------------
+/**
+ * Upgrades legacy wallet info structures into the new format.
+ *
+ * Wallets normally have `wallet:pluginId` as their type,
+ * but some legacy wallets also put format information into the wallet type.
+ * This routine moves the information out of the wallet type into the keys.
+ *
+ * It also provides some other default values as a historical accident,
+ * but the bitcoin plugin can just provide its own fallback values if
+ * `format` or `coinType` are missing. Please don't make the problem worse
+ * by adding more code here!
+ */
+function fixWalletInfo(walletInfo) {
+  const {
+    id,
+    keys,
+    type
+  } = walletInfo;
 
-const asEdgeAssetAmount = cleaners.asObject({
-  pluginId: cleaners.asString,
-  tokenId: asEdgeTokenId,
-  nativeAmount: cleaners.asOptional(asIntegerString)
-});
-const asEdgeFiatAmount = cleaners.asObject({
-  // core-js style fiat code including 'iso:'
-  fiatCurrencyCode: cleaners.asString,
-  fiatAmount: cleaners.asString
-});
-const asEdgeSwapInfo = cleaners.asObject({
-  pluginId: cleaners.asString,
-  displayName: cleaners.asString,
-  isDex: cleaners.asOptional(cleaners.asBoolean),
-  orderUri: cleaners.asOptional(cleaners.asString),
-  // The orderId would be appended to this
-  supportEmail: cleaners.asString
-});
-const asEdgeTxActionSwap = cleaners.asObject({
-  actionType: cleaners.asValue('swap'),
-  swapInfo: asEdgeSwapInfo,
-  orderId: cleaners.asOptional(cleaners.asString),
-  orderUri: cleaners.asOptional(cleaners.asString),
-  isEstimate: cleaners.asOptional(cleaners.asBoolean),
-  canBePartial: cleaners.asOptional(cleaners.asBoolean),
-  fromAsset: asEdgeAssetAmount,
-  toAsset: asEdgeAssetAmount,
-  payoutWalletId: cleaners.asString,
-  payoutAddress: cleaners.asString,
-  refundAddress: cleaners.asOptional(cleaners.asString)
-});
-const asEdgeTxActionStake = cleaners.asObject({
-  actionType: cleaners.asValue('stake'),
-  pluginId: cleaners.asString,
-  stakeAssets: cleaners.asArray(asEdgeAssetAmount)
-});
-const asEdgeTxActionFiat = cleaners.asObject({
-  actionType: cleaners.asValue('fiat'),
-  orderId: cleaners.asString,
-  orderUri: cleaners.asOptional(cleaners.asString),
-  isEstimate: cleaners.asBoolean,
-  fiatPlugin: cleaners.asObject({
-    providerId: cleaners.asString,
-    providerDisplayName: cleaners.asString,
-    supportEmail: cleaners.asOptional(cleaners.asString)
-  }),
-  payinAddress: cleaners.asOptional(cleaners.asString),
-  payoutAddress: cleaners.asOptional(cleaners.asString),
-  fiatAsset: asEdgeFiatAmount,
-  cryptoAsset: asEdgeAssetAmount
-});
-const asEdgeTxActionTokenApproval = cleaners.asObject({
-  actionType: cleaners.asValue('tokenApproval'),
-  tokenApproved: asEdgeAssetAmount,
-  tokenContractAddress: cleaners.asString,
-  contractAddress: cleaners.asString
-});
-const asEdgeTxActionGiftCard = cleaners.asObject({
-  actionType: cleaners.asValue('giftCard'),
-  orderId: cleaners.asString,
-  orderUri: cleaners.asOptional(cleaners.asString),
-  provider: cleaners.asObject({
-    providerId: cleaners.asString,
-    displayName: cleaners.asString,
-    supportEmail: cleaners.asOptional(cleaners.asString)
-  }),
-  card: cleaners.asObject({
-    name: cleaners.asString,
-    imageUrl: cleaners.asOptional(cleaners.asString),
-    fiatAmount: cleaners.asString,
-    fiatCurrencyCode: cleaners.asString
-  }),
-  redemption: cleaners.asOptional(cleaners.asObject({
-    code: cleaners.asOptional(cleaners.asString),
-    url: cleaners.asOptional(cleaners.asString)
-  }))
-});
-const asEdgeTxAction = cleaners.asEither(asEdgeTxActionSwap, asEdgeTxActionStake, asEdgeTxActionFiat, asEdgeTxActionTokenApproval, asEdgeTxActionGiftCard);
-const asEdgeAssetActionType = cleaners.asValue('claim', 'claimOrder', 'stake', 'stakeNetworkFee', 'stakeOrder', 'unstake', 'unstakeNetworkFee', 'unstakeOrder', 'swap', 'swapNetworkFee', 'swapOrderPost', 'swapOrderFill', 'swapOrderCancel', 'buy', 'sell', 'sellNetworkFee', 'tokenApproval', 'transfer', 'transferNetworkFee', 'giftCard');
-const asEdgeAssetAction = cleaners.asObject({
-  assetActionType: asEdgeAssetActionType
-});
+  // Wallet types we need to fix:
+  const defaults = {
+    // BTC:
+    'wallet:bitcoin-bip44': {
+      format: 'bip44',
+      coinType: 0
+    },
+    'wallet:bitcoin-bip49': {
+      format: 'bip49',
+      coinType: 0
+    },
+    // BCH:
+    'wallet:bitcoincash-bip32': {
+      format: 'bip32'
+    },
+    'wallet:bitcoincash-bip44': {
+      format: 'bip44',
+      coinType: 145
+    },
+    // BCH testnet:
+    'wallet:bitcoincash-bip44-testnet': {
+      format: 'bip44',
+      coinType: 1
+    },
+    // BTC testnet:
+    'wallet:bitcoin-bip44-testnet': {
+      format: 'bip44',
+      coinType: 1
+    },
+    'wallet:bitcoin-bip49-testnet': {
+      format: 'bip49',
+      coinType: 1
+    },
+    // DASH:
+    'wallet:dash-bip44': {
+      format: 'bip44',
+      coinType: 5
+    },
+    // DOGE:
+    'wallet:dogecoin-bip44': {
+      format: 'bip44',
+      coinType: 3
+    },
+    // LTC:
+    'wallet:litecoin-bip44': {
+      format: 'bip44',
+      coinType: 2
+    },
+    'wallet:litecoin-bip49': {
+      format: 'bip49',
+      coinType: 2
+    },
+    // FTC:
+    'wallet:feathercoin-bip49': {
+      format: 'bip49',
+      coinType: 8
+    },
+    'wallet:feathercoin-bip44': {
+      format: 'bip44',
+      coinType: 8
+    },
+    // QTUM:
+    'wallet:qtum-bip44': {
+      format: 'bip44',
+      coinType: 2301
+    },
+    // UFO:
+    'wallet:ufo-bip49': {
+      format: 'bip49',
+      coinType: 202
+    },
+    'wallet:ufo-bip84': {
+      format: 'bip84',
+      coinType: 202
+    },
+    // XZC:
+    'wallet:zcoin-bip44': {
+      format: 'bip44',
+      coinType: 136
+    },
+    // The plugin itself could handle these lines, but they are here
+    // as a historical accident. Please don't add more:
+    'wallet:bitcoin-testnet': {
+      format: 'bip32'
+    },
+    'wallet:bitcoin': {
+      format: 'bip32'
+    },
+    'wallet:bitcoincash-testnet': {
+      format: 'bip32'
+    },
+    'wallet:litecoin': {
+      format: 'bip32',
+      coinType: 2
+    },
+    'wallet:zcoin': {
+      format: 'bip32',
+      coinType: 136
+    }
+  };
+  if (defaults[type] != null) {
+    return {
+      id,
+      keys: {
+        ...defaults[type],
+        ...keys
+      },
+      type: type.replace(/-bip[0-9]+/, '')
+    };
+  }
+  return walletInfo;
+}
+async function makeCurrencyWalletKeys(ai, walletType, opts) {
+  const {
+    importText,
+    keyOptions,
+    keys
+  } = opts;
 
-/**
- * Old core versions used currency codes instead of tokenId's.
- */
-const asLegacyTokensFile = cleaners.asArray(cleaners.asString);
+  // Helper function to bundle up the keys:
+  function finalizeKeys(newKeys, imported) {
+    if (imported != null) newKeys = {
+      ...newKeys,
+      imported
+    };
+    return fixWalletInfo(makeKeyInfo(walletType, {
+      ...wasEdgeStorageKeys(createStorageKeys(ai)),
+      ...newKeys
+    }));
+  }
 
-/**
- * Stores enabled tokenId's on disk.
- */
-const asTokensFile = cleaners.asObject({
-  // All the tokens that the engine should check.
-  // This includes both manually-enabled tokens and auto-enabled tokens:
-  enabledTokenIds: cleaners.asArray(cleaners.asString),
-  // These tokenId's have been detected on-chain at least once.
-  // The user can still remove them from the enabled tokens list.
-  detectedTokenIds: cleaners.asArray(cleaners.asString)
-});
-const asTransactionAsset = cleaners.asObject({
-  assetAction: cleaners.asOptional(asEdgeAssetAction),
-  metadata: asEdgeMetadata,
-  nativeAmount: cleaners.asOptional(cleaners.asString),
-  providerFeeSent: cleaners.asOptional(cleaners.asString)
-});
-const asTransactionFile = cleaners.asObject({
-  txid: cleaners.asString,
-  internal: cleaners.asBoolean,
-  creationDate: cleaners.asNumber,
-  currencies: asMap(asTransactionAsset),
-  tokens: cleaners.asOptional(asTokenIdMap(asTransactionAsset), () => new Map()),
-  deviceDescription: cleaners.asOptional(cleaners.asString),
-  feeRateRequested: cleaners.asOptional(cleaners.asEither(asFeeRate, asJsonObject)),
-  feeRateUsed: cleaners.asOptional(asJsonObject),
-  payees: cleaners.asOptional(cleaners.asArray(cleaners.asObject({
-    address: cleaners.asString,
-    amount: cleaners.asString,
-    currency: cleaners.asString,
-    tag: cleaners.asOptional(cleaners.asString)
-  }))),
-  savedAction: cleaners.asOptional(asEdgeTxAction),
-  secret: cleaners.asOptional(cleaners.asString),
-  swap: cleaners.asOptional(asEdgeTxSwap)
-});
-const asLegacyTransactionFile = cleaners.asObject({
-  airbitzFeeWanted: cleaners.asNumber,
-  meta: cleaners.asObject({
-    amountFeeAirBitzSatoshi: cleaners.asNumber,
-    balance: cleaners.asNumber,
-    fee: cleaners.asNumber,
-    // Metadata:
-    amountCurrency: cleaners.asNumber,
-    bizId: cleaners.asNumber,
-    category: cleaners.asString,
-    name: cleaners.asString,
-    notes: cleaners.asString,
-    // Obsolete/moved fields:
-    attributes: cleaners.asNumber,
-    amountSatoshi: cleaners.asNumber,
-    amountFeeMinersSatoshi: cleaners.asNumber,
-    airbitzFee: cleaners.asNumber
-  }),
-  ntxid: cleaners.asString,
-  state: cleaners.asObject({
-    creationDate: cleaners.asNumber,
-    internal: cleaners.asBoolean,
-    malleableTxId: cleaners.asString
-  })
-});
-const asLegacyAddressFile = cleaners.asObject({
-  seq: cleaners.asNumber,
-  // index
-  address: cleaners.asString,
-  state: cleaners.asObject({
-    recycleable: cleaners.asOptional(cleaners.asBoolean, true),
-    creationDate: cleaners.asOptional(cleaners.asNumber, 0)
-  }),
-  meta: cleaners.asObject({
-    amountSatoshi: cleaners.asOptional(cleaners.asNumber, 0) // requestAmount
-    // TODO: Normal EdgeMetadata
-  }).withRest
-});
-const asLegacyMapFile = cleaners.asObject(cleaners.asObject({
-  timestamp: cleaners.asNumber,
-  txidHash: cleaners.asString
-}));
+  // If we have raw keys, just return those:
+  if (keys != null) return finalizeKeys(keys);
 
-/**
- * Public keys cached in the wallet's local storage.
- */
-const asPublicKeyFile = cleaners.asObject({
-  walletInfo: cleaners.asObject({
-    id: cleaners.asString,
-    keys: asJsonObject,
-    type: cleaners.asString
-  })
-});
+  // Grab the currency tools:
+  const pluginId = findCurrencyPluginId(ai.props.state.plugins.currency, walletType);
+  const tools = await getCurrencyTools(ai, pluginId);
 
-/**
- * The wallet's local storage file for the last seen "checkpoint". The core
- * does not know the contents of the checkpoint, so it just as an arbitrary
- * string.
- */
-const asSeenCheckpointFile = cleaners.asObject({
-  checkpoint: cleaners.asOptional(cleaners.asString),
-  subscribedAddresses: cleaners.asOptional(cleaners.asArray(cleaners.asObject({
-    address: cleaners.asString,
-    checkpoint: cleaners.asOptional(cleaners.asString)
-  })), () => [])
-});
-const asWalletFiatFile = cleaners.asObject({
-  fiat: cleaners.asOptional(cleaners.asString),
-  num: cleaners.asOptional(cleaners.asNumber)
-});
-const asWalletNameFile = cleaners.asObject({
-  walletName: cleaners.asEither(cleaners.asString, cleaners.asNull)
-});
+  // If we have text to import, use that:
+  if (importText != null) {
+    if (tools.importPrivateKey == null) {
+      throw new Error('This wallet does not support importing keys');
+    }
+    return finalizeKeys(await tools.importPrivateKey(importText, keyOptions), true);
+  }
 
-function shuffle(arr) {
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [arr[i], arr[j]] = [arr[j], arr[i]];
+  // Derive fresh keys:
+  return finalizeKeys(await tools.createPrivateKey(walletType, keyOptions), false);
+}
+async function finishWalletCreation(ai, accountId, walletId, opts) {
+  const {
+    enabledTokenIds,
+    fiatCurrencyCode,
+    migratedFromWalletId,
+    name
+  } = opts;
+  const wallet = await waitForCurrencyWallet(ai, walletId);
+
+  // Write ancillary files to disk:
+  if (migratedFromWalletId != null) {
+    await changeWalletStates(ai, accountId, {
+      [walletId]: {
+        migratedFromWalletId
+      }
+    });
   }
-  return arr;
+  if (name != null) {
+    await wallet.renameWallet(name);
+  }
+  if (fiatCurrencyCode != null) {
+    await wallet.setFiatCurrencyCode(fiatCurrencyCode);
+  }
+  if (enabledTokenIds != null && enabledTokenIds.length > 0) {
+    await wallet.changeEnabledTokenIds(enabledTokenIds);
+  }
+  return wallet;
+}
+function getLast(array) {
+  return array[array.length - 1];
+}
+
+/**
+ * Returns the earliest date, or undefined if neither date exists.
+ */
+function mergeKeyDate(a, b) {
+  if (a == null) return b;
+  if (b == null) return a;
+  return new Date(Math.min(a.valueOf(), b.valueOf()));
 }
 
 const legacyWalletFile = makeJsonFile(asLegacyWalletFile);
@@ -4297,440 +4243,737 @@ async function reloadPluginSettings(ai, accountId) {
   });
 }
 
-/**
- * A key that decrypts a login stash.
- */
+async function listSplittableWalletTypes(ai, accountId, walletId) {
+  const {
+    allWalletInfosFull
+  } = ai.props.state.accounts[accountId];
 
-/**
- * The login data decrypted into memory.
- * @deprecated Use `LoginStash` instead and decrypt it at the point of use.
- * This is an ongoing refactor to remove this type.
- */
+  // Find the wallet we are going to split:
+  const walletInfo = allWalletInfosFull.find(walletInfo => walletInfo.id === walletId);
+  if (walletInfo == null) throw new Error(`Invalid wallet id ${walletId}`);
+  const pluginId = maybeFindCurrencyPluginId(ai.props.state.plugins.currency, walletInfo.type);
+  if (pluginId == null) return [];
 
-/**
- * A stash for a specific child account,
- * along with its containing tree.
- */
+  // Get the list of available types:
+  const tools = await getCurrencyTools(ai, pluginId);
+  if (tools.getSplittableTypes == null) return [];
+  const types = await tools.getSplittableTypes(walletInfo);
 
-const asEdgeWalletInfo = cleaners.asObject({
-  id: cleaners.asString,
-  keys: asJsonObject,
-  type: cleaners.asString
-});
-const wasEdgeWalletInfo = cleaners.uncleaner(asEdgeWalletInfo);
+  // Filter out wallet types we have already split:
+  return types.filter(type => {
+    const newWalletInfo = makeSplitWalletInfo(walletInfo, type);
+    const existingWalletInfo = allWalletInfosFull.find(walletInfo => walletInfo.id === newWalletInfo.id);
+    // We can split the wallet if it doesn't exist, or is deleted:
+    return existingWalletInfo == null || existingWalletInfo.archived || existingWalletInfo.deleted;
+  });
+}
+function makeSplitWalletInfo(walletInfo, newWalletType) {
+  const {
+    id,
+    type,
+    keys
+  } = walletInfo;
+  const cleanKeys = cleaners.asMaybe(asEdgeStorageKeys)(keys);
+  if (cleanKeys == null) {
+    throw new Error(`Wallet ${id} is not a splittable type`);
+  }
+  const {
+    dataKey,
+    syncKey
+  } = cleanKeys;
+  const xorKey = xorData(hmacSha256(utf8.parse(type), dataKey), hmacSha256(utf8.parse(newWalletType), dataKey));
 
-/**
- * Returns the first keyInfo with a matching type.
- */
-function findFirstKey(keyInfos, type) {
-  return keyInfos.find(info => info.type === type);
+  // Fix the id:
+  const newWalletId = xorData(rfc4648.base64.parse(id), xorKey);
+  const newSyncKey = xorData(syncKey, xorKey.subarray(0, syncKey.length));
+
+  // Fix the keys:
+  const networkName = type.replace(/wallet:/, '').replace('-', '');
+  const newNetworkName = newWalletType.replace(/wallet:/, '').replace('-', '');
+  const newKeys = wasEdgeStorageKeys({
+    dataKey,
+    syncKey: newSyncKey
+  });
+  for (const key of Object.keys(keys)) {
+    const newKey = key === networkName + 'Key' ? newNetworkName + 'Key' : key;
+    if (newKeys[newKey] != null) continue;
+    newKeys[newKey] = keys[key];
+  }
+  return {
+    id: rfc4648.base64.stringify(newWalletId),
+    keys: newKeys,
+    type: newWalletType
+  };
 }
-function makeAccountType(appId) {
-  return appId === '' ? 'account-repo:co.airbitz.wallet' : `account-repo:${appId}`;
+async function splitWalletInfo(ai, accountId, walletInfo, splitWallets, rejectDupes) {
+  const accountState = ai.props.state.accounts[accountId];
+  const {
+    allWalletInfosFull,
+    sessionKey
+  } = accountState;
+
+  // Validate the wallet types:
+  const plugins = ai.props.state.plugins.currency;
+  const splitInfos = new Map();
+  for (const item of splitWallets) {
+    const {
+      walletType
+    } = item;
+    const pluginId = maybeFindCurrencyPluginId(plugins, item.walletType);
+    if (pluginId == null) {
+      throw new Error(`Cannot find plugin for wallet type "${walletType}"`);
+    }
+    if (splitInfos.has(walletType)) {
+      throw new Error(`Duplicate wallet type "${walletType}"`);
+    }
+    splitInfos.set(walletType, makeSplitWalletInfo(walletInfo, walletType));
+  }
+
+  // Do we need BitcoinABC/SV replay protection?
+  const needsProtection = walletInfo.type === 'wallet:bitcoincash' &&
+  // We can re-protect a wallet by doing a repeated split,
+  // so don't check if the wallet already exists:
+  splitInfos.has('wallet:bitcoinsv');
+  if (needsProtection) {
+    const existingWallet = ai.props.output?.currency?.wallets[walletInfo.id]?.walletApi;
+    if (existingWallet == null) {
+      throw new Error(`Cannot find wallet ${walletInfo.id}`);
+    }
+    await protectBchWallet(existingWallet);
+  }
+
+  // Sort the wallet infos into two categories:
+  const toRestore = [];
+  const toCreate = [];
+  for (const newWalletInfo of splitInfos.values()) {
+    const existingWalletInfo = allWalletInfosFull.find(info => info.id === newWalletInfo.id);
+    if (existingWalletInfo == null) {
+      toCreate.push(newWalletInfo);
+    } else {
+      if (existingWalletInfo.archived || existingWalletInfo.deleted) {
+        toRestore.push(existingWalletInfo);
+      } else if (rejectDupes) {
+        if (
+        // It's OK to re-split if we are adding protection:
+        walletInfo.type !== 'wallet:bitcoincash' || newWalletInfo.type !== 'wallet:bitcoinsv') {
+          throw new Error(`This wallet has already been split (${newWalletInfo.type})`);
+        }
+      }
+    }
+  }
+
+  // Restore anything that has simply been deleted:
+  if (toRestore.length > 0) {
+    const newStates = {};
+    let hasChanges = false;
+    for (const existingWalletInfo of toRestore) {
+      if (existingWalletInfo.archived || existingWalletInfo.deleted) {
+        hasChanges = true;
+        newStates[existingWalletInfo.id] = {
+          archived: false,
+          deleted: false,
+          migratedFromWalletId: existingWalletInfo.migratedFromWalletId
+        };
+      }
+    }
+    if (hasChanges) await changeWalletStates(ai, accountId, newStates);
+  }
+
+  // Add the keys to the login:
+  if (toCreate.length > 0) {
+    const kit = makeKeysKit(ai, sessionKey, toCreate, true);
+    await applyKit(ai, sessionKey, kit);
+  }
+
+  // Wait for the new wallets to load:
+  const out = await Promise.all(splitWallets.map(async splitInfo => {
+    const walletInfo = splitInfos.get(splitInfo.walletType);
+    if (walletInfo == null) {
+      throw new Error(`Missing wallet info for ${splitInfo.walletType}`);
+    }
+    return await makeEdgeResult(finishWalletSplitting(ai, walletInfo.id, toCreate.find(info => info.type === splitInfo.walletType) != null ? splitInfo : undefined));
+  }));
+  return out;
+}
+async function finishWalletSplitting(ai, walletId, item) {
+  const wallet = await waitForCurrencyWallet(ai, walletId);
+
+  // Try to copy metadata on a best-effort basis.
+  // In the future we should clone the repo instead:
+  if (item?.name != null) {
+    await wallet.renameWallet(item.name).catch(error => ai.props.onError(error));
+  }
+  if (item?.fiatCurrencyCode != null) {
+    await wallet.setFiatCurrencyCode(item.fiatCurrencyCode).catch(error => ai.props.onError(error));
+  }
+  return wallet;
+}
+async function protectBchWallet(wallet) {
+  const bchCurrency = {
+    currencyCode: 'BCH',
+    tokenId: null
+  };
+
+  // Create a UTXO which can be spend only on the ABC network
+  const spendInfoSplit = {
+    ...bchCurrency,
+    spendTargets: [{
+      nativeAmount: '10000',
+      otherParams: {
+        script: {
+          type: 'replayProtection'
+        }
+      },
+      publicAddress: ''
+    }],
+    metadata: {},
+    networkFeeOption: 'high'
+  };
+  const splitTx = await wallet.makeSpend(spendInfoSplit);
+  const signedSplitTx = await wallet.signTx(splitTx);
+  const broadcastedSplitTx = await wallet.broadcastTx(signedSplitTx);
+  await wallet.saveTx(broadcastedSplitTx);
+
+  // Taint the rest of the wallet using the UTXO from before
+  const {
+    publicAddress
+  } = await wallet.getReceiveAddress(bchCurrency);
+  const spendInfoTaint = {
+    ...bchCurrency,
+    metadata: {
+      name: 'Replay Protection Tx',
+      notes: 'This transaction is to protect your BCH wallet from unintentionally spending BSV funds. Please wait for the transaction to confirm before making additional transactions using this BCH wallet.'
+    },
+    networkFeeOption: 'high',
+    spendTargets: [{
+      publicAddress,
+      nativeAmount: '0'
+    }]
+  };
+  const maxAmount = await wallet.getMaxSpendable(spendInfoTaint);
+  spendInfoTaint.spendTargets[0].nativeAmount = maxAmount;
+  const taintTx = await wallet.makeSpend(spendInfoTaint);
+  const signedTaintTx = await wallet.signTx(taintTx);
+  const broadcastedTaintTx = await wallet.broadcastTx(signedTaintTx);
+  await wallet.saveTx(broadcastedTaintTx);
 }
 
 /**
- * Assembles the key metadata structure that is encrypted within a keyBox.
- * @param idKey Used to derive the wallet id. It's usually `dataKey`.
+ * Combines two byte arrays via the XOR operation.
  */
-function makeKeyInfo(type, keys, idKey) {
-  const hash = hmacSha256(utf8.parse(type), idKey ?? asEdgeStorageKeys(keys).dataKey);
-  return {
-    id: rfc4648.base64.stringify(hash),
-    type,
-    keys
-  };
+function xorData(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Array lengths do not match: ${a.length}, ${b.length}`);
+  }
+  const out = new Uint8Array(a.length);
+  for (let i = 0; i < a.length; ++i) {
+    out[i] = a[i] ^ b[i];
+  }
+  return out;
 }
 
-/**
- * Assembles all the resources needed to attach new keys to the account.
- * @param allowExisting True if the sync keys were derived deterministically,
- * which implies that duplicate sync keys on the server are not errors,
- * but leftovers from an earlier failed splitting attempt.
- */
-function makeKeysKit(ai, sessionKey, keyInfos, allowExisting = false) {
-  // For crash errors:
-  ai.props.log.breadcrumb('makeKeysKit', {});
+function makeStorageWalletApi(ai, walletInfo) {
   const {
-    io
-  } = ai.props;
-  const keyBoxes = keyInfos.map(info => ({
-    created: new Date(),
-    ...encrypt(io, utf8.parse(JSON.stringify(wasEdgeWalletInfo(info))), sessionKey.loginKey)
-  }));
-  const newSyncKeys = [];
-  for (const info of keyInfos) {
-    const storageKeys = cleaners.asMaybe(asEdgeStorageKeys)(info.keys);
-    if (storageKeys == null) continue;
-    newSyncKeys.push(rfc4648.base16.stringify(storageKeys.syncKey).toLowerCase());
-  }
+    id,
+    type,
+    keys
+  } = walletInfo;
   return {
-    loginId: sessionKey.loginId,
-    server: wasCreateKeysPayload({
-      allowExisting,
-      keyBoxes,
-      newSyncKeys
-    }),
-    serverPath: '/v2/login/keys',
-    stash: {
-      keyBoxes
+    // Broken-out key info:
+    id,
+    type,
+    keys,
+    // Folders:
+    get disklet() {
+      return getStorageWalletDisklet(ai.props.state, id);
+    },
+    get localDisklet() {
+      return getStorageWalletLocalDisklet(ai.props.state, id);
+    },
+    async sync() {
+      await syncStorageWallet(ai, id);
     }
   };
 }
 
+const TYPED_ARRAYS = {
+  '[object Float32Array]': true,
+  '[object Float64Array]': true,
+  '[object Int16Array]': true,
+  '[object Int32Array]': true,
+  '[object Int8Array]': true,
+  '[object Uint16Array]': true,
+  '[object Uint32Array]': true,
+  '[object Uint8Array]': true,
+  '[object Uint8ClampedArray]': true
+};
+
 /**
- * Flattens an array of key structures, removing duplicates.
+ * Compares two objects that are already known to have a common `[[Class]]`.
  */
-function mergeKeyInfos(keyInfos) {
-  const out = [];
-  const ids = new Map(); // Maps ID's to output array indexes
+function compareObjects(a, b, type) {
+  // User-created objects:
+  if (type === '[object Object]') {
+    const proto = Object.getPrototypeOf(a);
+    if (proto !== Object.getPrototypeOf(b)) return false;
+    const keys = Object.getOwnPropertyNames(a);
+    if (keys.length !== Object.getOwnPropertyNames(b).length) return false;
 
-  for (const keyInfo of keyInfos) {
-    const {
-      id,
-      keys,
-      type
-    } = keyInfo;
-    if (id == null || rfc4648.base64.parse(id).length !== 32) {
-      throw new Error(`Key integrity violation: invalid id ${id}`);
-    }
-    const index = ids.get(id);
-    if (index != null) {
-      // We have already seen this id, so check for conflicts:
-      const old = out[index];
-      if (old.type !== type) {
-        throw new Error(`Key integrity violation for ${id}: type ${type} does not match ${old.type}`);
-      }
-      for (const key of Object.keys(keys)) {
-        if (old.keys[key] != null && old.keys[key] !== keys[key]) {
-          throw new Error(`Key integrity violation for ${id}: ${key} keys do not match`);
-        }
+    // We know that both objects have the same number of properties,
+    // so if every property in `a` has a matching property in `b`,
+    // the objects must be identical, regardless of key order.
+    for (const key of keys) {
+      if (!Object.prototype.hasOwnProperty.call(b, key) || !compare(a[key], b[key])) {
+        return false;
       }
+    }
+    return true;
+  }
 
-      // Do the update:
-      out[index] = {
-        id,
-        keys: {
-          ...old.keys,
-          ...keys
-        },
-        type
-      };
-    } else {
-      // We haven't seen this id, so insert it:
-      ids.set(id, out.length);
-      out.push(keyInfo);
+  // Arrays:
+  if (type === '[object Array]') {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; ++i) {
+      if (!compare(a[i], b[i])) return false;
     }
+    return true;
   }
-  return out;
+
+  // Javascript dates:
+  if (type === '[object Date]') {
+    return a.getTime() === b.getTime();
+  }
+  if (type === '[object Map]') {
+    return compareMap(a, b);
+  }
+
+  // Typed arrays:
+  if (TYPED_ARRAYS[type]) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; ++i) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+
+  // We don't even try comparing anything else:
+  return false;
 }
 
 /**
- * Decrypts the private keys contained in a login.
+ * Compare Maps
  */
-function decryptKeyInfos(stash, loginKey, keyDates = new Map()) {
-  const {
-    appId,
-    keyBoxes = []
-  } = stash;
-  const legacyKeys = [];
-
-  // BitID wallet:
-  const {
-    mnemonicBox,
-    rootKeyBox
-  } = stash;
-  if (mnemonicBox != null && rootKeyBox != null) {
-    const rootKey = decrypt(rootKeyBox, loginKey);
-    const infoKey = hmacSha256(rootKey, utf8.parse('infoKey'));
-    const keys = {
-      mnemonic: decryptText(mnemonicBox, infoKey),
-      rootKey: rfc4648.base64.stringify(rootKey)
-    };
-    legacyKeys.push(makeKeyInfo('wallet:bitid', keys, rootKey));
+function compareMap(map1, map2) {
+  if (map1.size !== map2.size) {
+    return false;
+  }
+  for (const [key, value] of map1) {
+    if (!map2.has(key) || map2.get(key) !== value) {
+      return false;
+    }
   }
+  return true;
+}
+/**
+ * Returns true if two Javascript values are equal in value.
+ */
+function compare(a, b) {
+  if (a === b) return true;
 
-  // Account settings:
-  if (stash.syncKeyBox != null) {
-    const syncKey = decrypt(stash.syncKeyBox, loginKey);
-    const type = makeAccountType(appId);
-    const keys = wasEdgeStorageKeys({
-      dataKey: loginKey,
-      syncKey
-    });
-    legacyKeys.push(makeKeyInfo(type, keys, loginKey));
+  // Fast path for primitives:
+  if (typeof a !== 'object') return false;
+  if (typeof b !== 'object') return false;
+
+  // If these are objects, the internal `[[Class]]` properties must match:
+  const type = Object.prototype.toString.call(a);
+  if (type !== Object.prototype.toString.call(b)) return false;
+  return compareObjects(a, b, type);
+}
+
+// How often to run jobs from the queue
+let QUEUE_RUN_DELAY = 500;
+
+// How many jobs to run from the queue on each cycle
+let QUEUE_JOBS_PER_RUN = 3;
+const updateQueue = [];
+function enableTestMode() {
+  QUEUE_JOBS_PER_RUN = 99;
+  QUEUE_RUN_DELAY = 1;
+}
+function pushUpdate(update) {
+  if (updateQueue.length <= 0) {
+    startQueue();
+  }
+  let didUpdate = false;
+  for (const u of updateQueue) {
+    if (u.id === update.id && u.action === update.action) {
+      u.updateFunc = update.updateFunc;
+      didUpdate = true;
+      break;
+    }
   }
+  if (!didUpdate) {
+    updateQueue.push(update);
+  }
+}
+function startQueue() {
+  setTimeout(() => {
+    const numJobs = Math.min(QUEUE_JOBS_PER_RUN, updateQueue.length);
+    for (let i = 0; i < numJobs; i++) {
+      const u = updateQueue.shift();
+      if (u != null) u.updateFunc();
+    }
+    if (updateQueue.length > 0) {
+      startQueue();
+    }
+  }, QUEUE_RUN_DELAY);
+}
 
-  // Keys:
-  const keyInfos = keyBoxes.map(box => {
-    const keys = asEdgeWalletInfo(JSON.parse(decryptText(box, loginKey)));
-    const created = mergeKeyDate(box.created, keyDates.get(keys.id));
-    if (created != null) keyDates.set(keys.id, created);
-    return keys;
+/**
+ * Reads a JSON-style object into a JavaScript `Map` object with string keys.
+ */
+function asMap(cleaner) {
+  const asJsonObject = cleaners.asObject(cleaner);
+  return cleaners.asCodec(raw => {
+    const clean = asJsonObject(raw);
+    const out = new Map();
+    for (const key of Object.keys(clean)) out.set(key, clean[key]);
+    return out;
+  }, clean => {
+    const out = {};
+    clean.forEach((value, key) => {
+      out[key] = value;
+    });
+    return asJsonObject(out);
   });
-  return mergeKeyInfos([...legacyKeys, ...keyInfos]).map(walletInfo => fixWalletInfo(walletInfo));
 }
 
 /**
- * Returns all the wallet infos accessible from this login object.
+ * Reads a JSON-style object into a JavaScript `Map` object
+ * with EdgeTokenId keys.
  */
-function decryptAllWalletInfos(stashTree, sessionKey, legacyWalletInfos, walletStates) {
-  // Maps from walletId's to appId's:
-  const dates = new Map();
-  const appIdMap = new Map();
-  const walletInfos = [...legacyWalletInfos];
-
-  // Navigate to the starting node:
-  const stash = getChildStash(stashTree, sessionKey.loginId);
-
-  // Add the legacy wallets first:
-  for (const info of legacyWalletInfos) {
-    walletInfos.push(info);
-    const appIds = appIdMap.get(info.id);
-    if (appIds != null) appIds.push(stash.appId);else appIdMap.set(info.id, [stash.appId]);
-  }
-  function getAllWalletInfosLoop(stash, loginKey) {
-    // Add our own walletInfos:
-    const keyInfos = decryptKeyInfos(stash, loginKey, dates);
-    for (const info of keyInfos) {
-      walletInfos.push(info);
-      const appIds = appIdMap.get(info.id);
-      if (appIds != null) appIds.push(stash.appId);else appIdMap.set(info.id, [stash.appId]);
-    }
-
-    // Add our children's walletInfos:
-    for (const child of stash.children ?? []) {
-      if (child.parentBox == null) continue;
-      getAllWalletInfosLoop(child, decrypt(child.parentBox, loginKey));
+function asTokenIdMap(cleaner) {
+  const asJsonObject = cleaners.asObject(cleaner);
+  return cleaners.asCodec(raw => {
+    const clean = asJsonObject(raw);
+    const out = new Map();
+    for (const key of Object.keys(clean)) {
+      out.set(key === '' ? null : key, clean[key]);
     }
-  }
-  getAllWalletInfosLoop(stash, sessionKey.loginKey);
-  return mergeKeyInfos(walletInfos).map(info => {
-    return {
-      appId: getLast(appIdMap.get(info.id) ?? []),
-      appIds: appIdMap.get(info.id) ?? [],
-      // Defaults to be overwritten:
-      archived: false,
-      created: dates.get(info.id),
-      deleted: false,
-      hidden: false,
-      sortIndex: walletInfos.length,
-      // Copy the `imported` field from the raw keys if it exists
-      imported: info.keys.imported,
-      // Actual info:
-      ...walletStates[info.id],
-      ...info
-    };
+    return out;
+  }, clean => {
+    const out = {};
+    clean.forEach((value, key) => {
+      out[key == null ? '' : key] = value;
+    });
+    return asJsonObject(out);
   });
 }
 
-/**
- * Upgrades legacy wallet info structures into the new format.
- *
- * Wallets normally have `wallet:pluginId` as their type,
- * but some legacy wallets also put format information into the wallet type.
- * This routine moves the information out of the wallet type into the keys.
- *
- * It also provides some other default values as a historical accident,
- * but the bitcoin plugin can just provide its own fallback values if
- * `format` or `coinType` are missing. Please don't make the problem worse
- * by adding more code here!
- */
-function fixWalletInfo(walletInfo) {
+const asEdgeMetadata = raw => {
+  const clean = asDiskMetadata(raw);
   const {
-    id,
-    keys,
-    type
-  } = walletInfo;
+    exchangeAmount = {}
+  } = clean;
 
-  // Wallet types we need to fix:
-  const defaults = {
-    // BTC:
-    'wallet:bitcoin-bip44': {
-      format: 'bip44',
-      coinType: 0
-    },
-    'wallet:bitcoin-bip49': {
-      format: 'bip49',
-      coinType: 0
-    },
-    // BCH:
-    'wallet:bitcoincash-bip32': {
-      format: 'bip32'
-    },
-    'wallet:bitcoincash-bip44': {
-      format: 'bip44',
-      coinType: 145
-    },
-    // BCH testnet:
-    'wallet:bitcoincash-bip44-testnet': {
-      format: 'bip44',
-      coinType: 1
-    },
-    // BTC testnet:
-    'wallet:bitcoin-bip44-testnet': {
-      format: 'bip44',
-      coinType: 1
-    },
-    'wallet:bitcoin-bip49-testnet': {
-      format: 'bip49',
-      coinType: 1
-    },
-    // DASH:
-    'wallet:dash-bip44': {
-      format: 'bip44',
-      coinType: 5
-    },
-    // DOGE:
-    'wallet:dogecoin-bip44': {
-      format: 'bip44',
-      coinType: 3
-    },
-    // LTC:
-    'wallet:litecoin-bip44': {
-      format: 'bip44',
-      coinType: 2
-    },
-    'wallet:litecoin-bip49': {
-      format: 'bip49',
-      coinType: 2
-    },
-    // FTC:
-    'wallet:feathercoin-bip49': {
-      format: 'bip49',
-      coinType: 8
-    },
-    'wallet:feathercoin-bip44': {
-      format: 'bip44',
-      coinType: 8
-    },
-    // QTUM:
-    'wallet:qtum-bip44': {
-      format: 'bip44',
-      coinType: 2301
-    },
-    // UFO:
-    'wallet:ufo-bip49': {
-      format: 'bip49',
-      coinType: 202
-    },
-    'wallet:ufo-bip84': {
-      format: 'bip84',
-      coinType: 202
-    },
-    // XZC:
-    'wallet:zcoin-bip44': {
-      format: 'bip44',
-      coinType: 136
-    },
-    // The plugin itself could handle these lines, but they are here
-    // as a historical accident. Please don't add more:
-    'wallet:bitcoin-testnet': {
-      format: 'bip32'
-    },
-    'wallet:bitcoin': {
-      format: 'bip32'
-    },
-    'wallet:bitcoincash-testnet': {
-      format: 'bip32'
-    },
-    'wallet:litecoin': {
-      format: 'bip32',
-      coinType: 2
-    },
-    'wallet:zcoin': {
-      format: 'bip32',
-      coinType: 136
+  // Delete corrupt amounts that exceed the Javascript number range:
+  for (const fiat of Object.keys(exchangeAmount)) {
+    if (String(exchangeAmount[fiat]).includes('e')) {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete exchangeAmount[fiat];
     }
-  };
-  if (defaults[type] != null) {
-    return {
-      id,
-      keys: {
-        ...defaults[type],
-        ...keys
-      },
-      type: type.replace(/-bip[0-9]+/, '')
-    };
   }
-  return walletInfo;
-}
-async function makeCurrencyWalletKeys(ai, walletType, opts) {
+  return clean;
+};
+function mergeMetadata(under, over) {
+  const out = {
+    exchangeAmount: {}
+  };
   const {
-    importText,
-    keyOptions,
-    keys
-  } = opts;
+    exchangeAmount = {}
+  } = out;
 
-  // Helper function to bundle up the keys:
-  function finalizeKeys(newKeys, imported) {
-    if (imported != null) newKeys = {
-      ...newKeys,
-      imported
-    };
-    return fixWalletInfo(makeKeyInfo(walletType, {
-      ...wasEdgeStorageKeys(createStorageKeys(ai)),
-      ...newKeys
-    }));
+  // Merge the fiat amounts:
+  const underAmounts = under.exchangeAmount ?? {};
+  const overAmounts = over.exchangeAmount ?? {};
+  for (const fiat of Object.keys(underAmounts)) {
+    if (overAmounts[fiat] !== null) exchangeAmount[fiat] = underAmounts[fiat];
+  }
+  for (const fiat of Object.keys(overAmounts)) {
+    const amount = overAmounts[fiat];
+    if (amount != null) exchangeAmount[fiat] = amount;
   }
 
-  // If we have raw keys, just return those:
-  if (keys != null) return finalizeKeys(keys);
+  // Merge simple fields:
+  if (over.bizId !== null) out.bizId = over.bizId ?? under.bizId;
+  if (over.category !== null) out.category = over.category ?? under.category;
+  if (over.name !== null) out.name = over.name ?? under.name;
+  if (over.notes !== null) out.notes = over.notes ?? under.notes;
+  return out;
+}
+const asDiskMetadata = cleaners.asObject({
+  bizId: cleaners.asOptional(cleaners.asNumber),
+  category: cleaners.asOptional(cleaners.asString),
+  exchangeAmount: cleaners.asOptional(cleaners.asObject(cleaners.asNumber)),
+  name: cleaners.asOptional(cleaners.asString),
+  notes: cleaners.asOptional(cleaners.asString)
+});
+
+/**
+ * The on-disk transaction format.
+ */
 
-  // Grab the currency tools:
-  const pluginId = findCurrencyPluginId(ai.props.state.plugins.currency, walletType);
-  const tools = await getCurrencyTools(ai, pluginId);
+/**
+ * The Airbitz on-disk transaction format.
+ */
 
-  // If we have text to import, use that:
-  if (importText != null) {
-    if (tools.importPrivateKey == null) {
-      throw new Error('This wallet does not support importing keys');
-    }
-    return finalizeKeys(await tools.importPrivateKey(importText, keyOptions), true);
-  }
+/**
+ * The Airbitz on-disk address format.
+ */
 
-  // Derive fresh keys:
-  return finalizeKeys(await tools.createPrivateKey(walletType, keyOptions), false);
-}
-async function finishWalletCreation(ai, accountId, walletId, opts) {
-  const {
-    enabledTokenIds,
-    fiatCurrencyCode,
-    migratedFromWalletId,
-    name
-  } = opts;
-  const wallet = await waitForCurrencyWallet(ai, walletId);
+/**
+ * An on-disk cache to quickly map Airbitz filenames to their dates.
+ */
 
-  // Write ancillary files to disk:
-  if (migratedFromWalletId != null) {
-    await changeWalletStates(ai, accountId, {
-      [walletId]: {
-        migratedFromWalletId
-      }
-    });
-  }
-  if (name != null) {
-    await wallet.renameWallet(name);
-  }
-  if (fiatCurrencyCode != null) {
-    await wallet.setFiatCurrencyCode(fiatCurrencyCode);
-  }
-  if (enabledTokenIds != null && enabledTokenIds.length > 0) {
-    await wallet.changeEnabledTokenIds(enabledTokenIds);
+// ---------------------------------------------------------------------
+// building-block cleaners
+// ---------------------------------------------------------------------
+const asEdgeTokenId = cleaners.asEither(cleaners.asString, cleaners.asNull);
+const asFeeRate = cleaners.asValue('high', 'standard', 'low');
+const asEdgeTxSwap = cleaners.asObject({
+  orderId: cleaners.asOptional(cleaners.asString),
+  orderUri: cleaners.asOptional(cleaners.asString),
+  isEstimate: cleaners.asBoolean,
+  // The EdgeSwapInfo from the swap plugin:
+  plugin: cleaners.asObject({
+    pluginId: cleaners.asString,
+    displayName: cleaners.asString,
+    supportEmail: cleaners.asOptional(cleaners.asString)
+  }),
+  // Address information:
+  payoutAddress: cleaners.asString,
+  payoutCurrencyCode: cleaners.asString,
+  payoutTokenId: cleaners.asOptional(asEdgeTokenId),
+  payoutNativeAmount: cleaners.asString,
+  payoutWalletId: cleaners.asString,
+  refundAddress: cleaners.asOptional(cleaners.asString)
+});
+function asIntegerString(raw) {
+  const clean = cleaners.asString(raw);
+  if (!/^\d+$/.test(clean)) {
+    throw new Error('Expected an integer string');
   }
-  return wallet;
-}
-function getLast(array) {
-  return array[array.length - 1];
+  return clean;
 }
 
+// ---------------------------------------------------------------------
+// file cleaners
+// ---------------------------------------------------------------------
+
+const asEdgeAssetAmount = cleaners.asObject({
+  pluginId: cleaners.asString,
+  tokenId: asEdgeTokenId,
+  nativeAmount: cleaners.asOptional(asIntegerString)
+});
+const asEdgeFiatAmount = cleaners.asObject({
+  // core-js style fiat code including 'iso:'
+  fiatCurrencyCode: cleaners.asString,
+  fiatAmount: cleaners.asString
+});
+const asEdgeSwapInfo = cleaners.asObject({
+  pluginId: cleaners.asString,
+  displayName: cleaners.asString,
+  isDex: cleaners.asOptional(cleaners.asBoolean),
+  orderUri: cleaners.asOptional(cleaners.asString),
+  // The orderId would be appended to this
+  supportEmail: cleaners.asString
+});
+const asEdgeTxActionSwap = cleaners.asObject({
+  actionType: cleaners.asValue('swap'),
+  swapInfo: asEdgeSwapInfo,
+  orderId: cleaners.asOptional(cleaners.asString),
+  orderUri: cleaners.asOptional(cleaners.asString),
+  isEstimate: cleaners.asOptional(cleaners.asBoolean),
+  canBePartial: cleaners.asOptional(cleaners.asBoolean),
+  fromAsset: asEdgeAssetAmount,
+  toAsset: asEdgeAssetAmount,
+  payoutWalletId: cleaners.asString,
+  payoutAddress: cleaners.asString,
+  refundAddress: cleaners.asOptional(cleaners.asString)
+});
+const asEdgeTxActionStake = cleaners.asObject({
+  actionType: cleaners.asValue('stake'),
+  pluginId: cleaners.asString,
+  stakeAssets: cleaners.asArray(asEdgeAssetAmount)
+});
+const asEdgeTxActionFiat = cleaners.asObject({
+  actionType: cleaners.asValue('fiat'),
+  orderId: cleaners.asString,
+  orderUri: cleaners.asOptional(cleaners.asString),
+  isEstimate: cleaners.asBoolean,
+  fiatPlugin: cleaners.asObject({
+    providerId: cleaners.asString,
+    providerDisplayName: cleaners.asString,
+    supportEmail: cleaners.asOptional(cleaners.asString)
+  }),
+  payinAddress: cleaners.asOptional(cleaners.asString),
+  payoutAddress: cleaners.asOptional(cleaners.asString),
+  fiatAsset: asEdgeFiatAmount,
+  cryptoAsset: asEdgeAssetAmount
+});
+const asEdgeTxActionTokenApproval = cleaners.asObject({
+  actionType: cleaners.asValue('tokenApproval'),
+  tokenApproved: asEdgeAssetAmount,
+  tokenContractAddress: cleaners.asString,
+  contractAddress: cleaners.asString
+});
+const asEdgeTxActionGiftCard = cleaners.asObject({
+  actionType: cleaners.asValue('giftCard'),
+  orderId: cleaners.asString,
+  orderUri: cleaners.asOptional(cleaners.asString),
+  provider: cleaners.asObject({
+    providerId: cleaners.asString,
+    displayName: cleaners.asString,
+    supportEmail: cleaners.asOptional(cleaners.asString)
+  }),
+  card: cleaners.asObject({
+    name: cleaners.asString,
+    imageUrl: cleaners.asOptional(cleaners.asString),
+    fiatAmount: cleaners.asString,
+    fiatCurrencyCode: cleaners.asString
+  }),
+  redemption: cleaners.asOptional(cleaners.asObject({
+    code: cleaners.asOptional(cleaners.asString),
+    url: cleaners.asOptional(cleaners.asString)
+  }))
+});
+const asEdgeTxAction = cleaners.asEither(asEdgeTxActionSwap, asEdgeTxActionStake, asEdgeTxActionFiat, asEdgeTxActionTokenApproval, asEdgeTxActionGiftCard);
+const asEdgeAssetActionType = cleaners.asValue('claim', 'claimOrder', 'stake', 'stakeNetworkFee', 'stakeOrder', 'unstake', 'unstakeNetworkFee', 'unstakeOrder', 'swap', 'swapNetworkFee', 'swapOrderPost', 'swapOrderFill', 'swapOrderCancel', 'buy', 'sell', 'sellNetworkFee', 'tokenApproval', 'transfer', 'transferNetworkFee', 'giftCard');
+const asEdgeAssetAction = cleaners.asObject({
+  assetActionType: asEdgeAssetActionType
+});
+
+/**
+ * Old core versions used currency codes instead of tokenId's.
+ */
+const asLegacyTokensFile = cleaners.asArray(cleaners.asString);
+
+/**
+ * Stores enabled tokenId's on disk.
+ */
+const asTokensFile = cleaners.asObject({
+  // All the tokens that the engine should check.
+  // This includes both manually-enabled tokens and auto-enabled tokens:
+  enabledTokenIds: cleaners.asArray(cleaners.asString),
+  // These tokenId's have been detected on-chain at least once.
+  // The user can still remove them from the enabled tokens list.
+  detectedTokenIds: cleaners.asArray(cleaners.asString)
+});
+const asTransactionAsset = cleaners.asObject({
+  assetAction: cleaners.asOptional(asEdgeAssetAction),
+  metadata: asEdgeMetadata,
+  nativeAmount: cleaners.asOptional(cleaners.asString),
+  providerFeeSent: cleaners.asOptional(cleaners.asString)
+});
+const asTransactionFile = cleaners.asObject({
+  txid: cleaners.asString,
+  internal: cleaners.asBoolean,
+  creationDate: cleaners.asNumber,
+  currencies: asMap(asTransactionAsset),
+  tokens: cleaners.asOptional(asTokenIdMap(asTransactionAsset), () => new Map()),
+  deviceDescription: cleaners.asOptional(cleaners.asString),
+  feeRateRequested: cleaners.asOptional(cleaners.asEither(asFeeRate, asJsonObject)),
+  feeRateUsed: cleaners.asOptional(asJsonObject),
+  payees: cleaners.asOptional(cleaners.asArray(cleaners.asObject({
+    address: cleaners.asString,
+    amount: cleaners.asString,
+    currency: cleaners.asString,
+    tag: cleaners.asOptional(cleaners.asString)
+  }))),
+  savedAction: cleaners.asOptional(asEdgeTxAction),
+  secret: cleaners.asOptional(cleaners.asString),
+  swap: cleaners.asOptional(asEdgeTxSwap)
+});
+const asLegacyTransactionFile = cleaners.asObject({
+  airbitzFeeWanted: cleaners.asNumber,
+  meta: cleaners.asObject({
+    amountFeeAirBitzSatoshi: cleaners.asNumber,
+    balance: cleaners.asNumber,
+    fee: cleaners.asNumber,
+    // Metadata:
+    amountCurrency: cleaners.asNumber,
+    bizId: cleaners.asNumber,
+    category: cleaners.asString,
+    name: cleaners.asString,
+    notes: cleaners.asString,
+    // Obsolete/moved fields:
+    attributes: cleaners.asNumber,
+    amountSatoshi: cleaners.asNumber,
+    amountFeeMinersSatoshi: cleaners.asNumber,
+    airbitzFee: cleaners.asNumber
+  }),
+  ntxid: cleaners.asString,
+  state: cleaners.asObject({
+    creationDate: cleaners.asNumber,
+    internal: cleaners.asBoolean,
+    malleableTxId: cleaners.asString
+  })
+});
+const asLegacyAddressFile = cleaners.asObject({
+  seq: cleaners.asNumber,
+  // index
+  address: cleaners.asString,
+  state: cleaners.asObject({
+    recycleable: cleaners.asOptional(cleaners.asBoolean, true),
+    creationDate: cleaners.asOptional(cleaners.asNumber, 0)
+  }),
+  meta: cleaners.asObject({
+    amountSatoshi: cleaners.asOptional(cleaners.asNumber, 0) // requestAmount
+    // TODO: Normal EdgeMetadata
+  }).withRest
+});
+const asLegacyMapFile = cleaners.asObject(cleaners.asObject({
+  timestamp: cleaners.asNumber,
+  txidHash: cleaners.asString
+}));
+
 /**
- * Returns the earliest date, or undefined if neither date exists.
+ * Public keys cached in the wallet's local storage.
  */
-function mergeKeyDate(a, b) {
-  if (a == null) return b;
-  if (b == null) return a;
-  return new Date(Math.min(a.valueOf(), b.valueOf()));
+const asPublicKeyFile = cleaners.asObject({
+  walletInfo: cleaners.asObject({
+    id: cleaners.asString,
+    keys: asJsonObject,
+    type: cleaners.asString
+  })
+});
+
+/**
+ * The wallet's local storage file for the last seen "checkpoint". The core
+ * does not know the contents of the checkpoint, so it just as an arbitrary
+ * string.
+ */
+const asSeenCheckpointFile = cleaners.asObject({
+  checkpoint: cleaners.asOptional(cleaners.asString),
+  subscribedAddresses: cleaners.asOptional(cleaners.asArray(cleaners.asObject({
+    address: cleaners.asString,
+    checkpoint: cleaners.asOptional(cleaners.asString)
+  })), () => [])
+});
+const asWalletFiatFile = cleaners.asObject({
+  fiat: cleaners.asOptional(cleaners.asString),
+  num: cleaners.asOptional(cleaners.asNumber)
+});
+const asWalletNameFile = cleaners.asObject({
+  walletName: cleaners.asEither(cleaners.asString, cleaners.asNull)
+});
+
+function shuffle(arr) {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
 }
 
 const passwordAuthSnrp = userIdSnrp;
@@ -6817,6 +7060,9 @@ async function reloadWalletFiles(input, changes) {
 
 // Used for detectedTokenIds & enabledTokenIds:
 const initialTokenIds = [];
+const initialSyncStatus = {
+  totalRatio: 0
+};
 const currencyWalletInner = reduxKeto.buildReducer({
   accountId(state, action, next) {
     if (state != null) return state;
@@ -6982,15 +7228,15 @@ const currencyWalletInner = reduxKeto.buildReducer({
     }
     return state;
   },
-  syncRatio(state = 0, action) {
+  syncStatus(state = initialSyncStatus, action) {
     switch (action.type) {
-      case 'CURRENCY_ENGINE_CHANGED_SYNC_RATIO':
+      case 'CURRENCY_ENGINE_CHANGED_SYNC_STATUS':
         {
-          return action.payload.ratio;
+          return action.payload.status;
         }
       case 'CURRENCY_ENGINE_CLEARED':
         {
-          return 0;
+          return initialSyncStatus;
         }
     }
     return state;
@@ -7263,12 +7509,14 @@ function makeCurrencyWalletCallbacks(input) {
     onAddressesChecked(ratio) {
       pushUpdate({
         id: walletId,
-        action: 'onAddressesChecked',
+        action: 'onSyncStatusChanged',
         updateFunc: () => {
           input.props.dispatch({
-            type: 'CURRENCY_ENGINE_CHANGED_SYNC_RATIO',
+            type: 'CURRENCY_ENGINE_CHANGED_SYNC_STATUS',
             payload: {
-              ratio,
+              status: {
+                totalRatio: ratio
+              },
               walletId
             }
           });
@@ -7449,6 +7697,21 @@ function makeCurrencyWalletCallbacks(input) {
         }
       });
     },
+    onSyncStatusChanged(syncStatus) {
+      pushUpdate({
+        id: walletId,
+        action: 'onSyncStatusChanged',
+        updateFunc: () => {
+          input.props.dispatch({
+            type: 'CURRENCY_ENGINE_CHANGED_SYNC_STATUS',
+            payload: {
+              status: syncStatus,
+              walletId
+            }
+          });
+        }
+      });
+    },
     onTransactions(txEvents) {
       const {
         accountId,
@@ -7948,7 +8211,10 @@ function makeCurrencyWalletApi(input, engine, tools, publicWalletInfo) {
       return skipBlockHeight ? 0 : input.props.walletState.height;
     },
     get syncRatio() {
-      return input.props.walletState.syncRatio;
+      return input.props.walletState.syncStatus.totalRatio;
+    },
+    get syncStatus() {
+      return input.props.walletState.syncStatus;
     },
     get unactivatedTokenIds() {
       return input.props.walletState.unactivatedTokenIds;
@@ -8395,6 +8661,9 @@ function makeCurrencyWalletApi(input, engine, tools, publicWalletInfo) {
       await engine.resyncBlockchain();
       yaob.emit(out, 'transactionsRemoved', undefined);
     },
+    async split(splitWallets) {
+      return await splitWalletInfo(ai, accountId, walletInfo, splitWallets, false);
+    },
     // URI handling:
     async encodeUri(options) {
       return await tools.encodeUri(options, makeMetaTokens(input.props.state.accounts[accountId].customTokens[pluginId]));
@@ -9008,195 +9277,6 @@ async function deleteLogin(ai, login) {
   await loginFetch(ai, 'POST', '/v2/login/delete', request);
 }
 
-async function listSplittableWalletTypes(ai, accountId, walletId) {
-  const {
-    allWalletInfosFull
-  } = ai.props.state.accounts[accountId];
-
-  // Find the wallet we are going to split:
-  const walletInfo = allWalletInfosFull.find(walletInfo => walletInfo.id === walletId);
-  if (walletInfo == null) throw new Error(`Invalid wallet id ${walletId}`);
-  const pluginId = maybeFindCurrencyPluginId(ai.props.state.plugins.currency, walletInfo.type);
-  if (pluginId == null) return [];
-
-  // Get the list of available types:
-  const tools = await getCurrencyTools(ai, pluginId);
-  if (tools.getSplittableTypes == null) return [];
-  const types = await tools.getSplittableTypes(walletInfo);
-
-  // Filter out wallet types we have already split:
-  return types.filter(type => {
-    const newWalletInfo = makeSplitWalletInfo(walletInfo, type);
-    const existingWalletInfo = allWalletInfosFull.find(walletInfo => walletInfo.id === newWalletInfo.id);
-    // We can split the wallet if it doesn't exist, or is deleted:
-    return existingWalletInfo == null || existingWalletInfo.archived || existingWalletInfo.deleted;
-  });
-}
-function makeSplitWalletInfo(walletInfo, newWalletType) {
-  const {
-    id,
-    type,
-    keys
-  } = walletInfo;
-  const cleanKeys = cleaners.asMaybe(asEdgeStorageKeys)(keys);
-  if (cleanKeys == null) {
-    throw new Error(`Wallet ${id} is not a splittable type`);
-  }
-  const {
-    dataKey,
-    syncKey
-  } = cleanKeys;
-  const xorKey = xorData(hmacSha256(utf8.parse(type), dataKey), hmacSha256(utf8.parse(newWalletType), dataKey));
-
-  // Fix the id:
-  const newWalletId = xorData(rfc4648.base64.parse(id), xorKey);
-  const newSyncKey = xorData(syncKey, xorKey.subarray(0, syncKey.length));
-
-  // Fix the keys:
-  const networkName = type.replace(/wallet:/, '').replace('-', '');
-  const newNetworkName = newWalletType.replace(/wallet:/, '').replace('-', '');
-  const newKeys = wasEdgeStorageKeys({
-    dataKey,
-    syncKey: newSyncKey
-  });
-  for (const key of Object.keys(keys)) {
-    const newKey = key === networkName + 'Key' ? newNetworkName + 'Key' : key;
-    if (newKeys[newKey] != null) continue;
-    newKeys[newKey] = keys[key];
-  }
-  return {
-    id: rfc4648.base64.stringify(newWalletId),
-    keys: newKeys,
-    type: newWalletType
-  };
-}
-async function splitWalletInfo(ai, accountId, walletId, newWalletType) {
-  const accountState = ai.props.state.accounts[accountId];
-  const {
-    allWalletInfosFull,
-    sessionKey
-  } = accountState;
-
-  // Find the wallet we are going to split:
-  const walletInfo = allWalletInfosFull.find(walletInfo => walletInfo.id === walletId);
-  if (walletInfo == null) throw new Error(`Invalid wallet id ${walletId}`);
-
-  // Handle BCH / BTC+segwit special case:
-  if (newWalletType === 'wallet:bitcoincash' && walletInfo.type === 'wallet:bitcoin' && walletInfo.keys.format === 'bip49') {
-    throw new Error('Cannot split segwit-format Bitcoin wallets to Bitcoin Cash');
-  }
-
-  // Handle BitcoinABC/SV replay protection:
-  const needsProtection = newWalletType === 'wallet:bitcoinsv' && walletInfo.type === 'wallet:bitcoincash';
-  if (needsProtection) {
-    const oldWallet = ai.props.output.currency.wallets[walletId].walletApi;
-    if (oldWallet == null) throw new Error('Missing Wallet');
-    await protectBchWallet(oldWallet);
-  }
-
-  // See if the wallet has already been split:
-  const newWalletInfo = makeSplitWalletInfo(walletInfo, newWalletType);
-  const existingWalletInfo = allWalletInfosFull.find(walletInfo => walletInfo.id === newWalletInfo.id);
-  if (existingWalletInfo != null) {
-    if (existingWalletInfo.archived || existingWalletInfo.deleted) {
-      // Simply undelete the existing wallet:
-      const walletInfos = {};
-      walletInfos[newWalletInfo.id] = {
-        archived: false,
-        deleted: false,
-        migratedFromWalletId: existingWalletInfo.migratedFromWalletId
-      };
-      await changeWalletStates(ai, accountId, walletInfos);
-      return newWalletInfo.id;
-    }
-    if (needsProtection) return newWalletInfo.id;
-    throw new Error('This wallet has already been split');
-  }
-
-  // Add the keys to the login:
-  const kit = makeKeysKit(ai, sessionKey, [newWalletInfo], true);
-  await applyKit(ai, sessionKey, kit);
-
-  // Try to copy metadata on a best-effort basis.
-  // In the future we should clone the repo instead:
-  try {
-    const wallet = await waitForCurrencyWallet(ai, newWalletInfo.id);
-    const oldWallet = ai.props.output.currency.wallets[walletId].walletApi;
-    if (oldWallet != null) {
-      if (oldWallet.name != null) await wallet.renameWallet(oldWallet.name);
-      if (oldWallet.fiatCurrencyCode != null) {
-        await wallet.setFiatCurrencyCode(oldWallet.fiatCurrencyCode);
-      }
-    }
-  } catch (error) {
-    ai.props.onError(error);
-  }
-  return newWalletInfo.id;
-}
-async function protectBchWallet(wallet) {
-  const bchCurrency = {
-    currencyCode: 'BCH',
-    tokenId: null
-  };
-
-  // Create a UTXO which can be spend only on the ABC network
-  const spendInfoSplit = {
-    ...bchCurrency,
-    spendTargets: [{
-      nativeAmount: '10000',
-      otherParams: {
-        script: {
-          type: 'replayProtection'
-        }
-      },
-      publicAddress: ''
-    }],
-    metadata: {},
-    networkFeeOption: 'high'
-  };
-  const splitTx = await wallet.makeSpend(spendInfoSplit);
-  const signedSplitTx = await wallet.signTx(splitTx);
-  const broadcastedSplitTx = await wallet.broadcastTx(signedSplitTx);
-  await wallet.saveTx(broadcastedSplitTx);
-
-  // Taint the rest of the wallet using the UTXO from before
-  const {
-    publicAddress
-  } = await wallet.getReceiveAddress(bchCurrency);
-  const spendInfoTaint = {
-    ...bchCurrency,
-    metadata: {
-      name: 'Replay Protection Tx',
-      notes: 'This transaction is to protect your BCH wallet from unintentionally spending BSV funds. Please wait for the transaction to confirm before making additional transactions using this BCH wallet.'
-    },
-    networkFeeOption: 'high',
-    spendTargets: [{
-      publicAddress,
-      nativeAmount: '0'
-    }]
-  };
-  const maxAmount = await wallet.getMaxSpendable(spendInfoTaint);
-  spendInfoTaint.spendTargets[0].nativeAmount = maxAmount;
-  const taintTx = await wallet.makeSpend(spendInfoTaint);
-  const signedTaintTx = await wallet.signTx(taintTx);
-  const broadcastedTaintTx = await wallet.broadcastTx(signedTaintTx);
-  await wallet.saveTx(broadcastedTaintTx);
-}
-
-/**
- * Combines two byte arrays via the XOR operation.
- */
-function xorData(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`Array lengths do not match: ${a.length}, ${b.length}`);
-  }
-  const out = new Uint8Array(a.length);
-  for (let i = 0; i < a.length; ++i) {
-    out[i] = a[i] ^ b[i];
-  }
-  return out;
-}
-
 /**
  * Approves or rejects vouchers on the server.
  */
@@ -9543,7 +9623,9 @@ const makeMemoryWalletInner = async (ai, config, walletType, opts = {}) => {
   const log = makeLog(ai.props.logBackend, `${walletId}-${walletType}`);
   let balanceMap = new Map();
   let detectedTokenIds = [];
-  let syncRatio = 0;
+  let syncStatus = {
+    totalRatio: 0
+  };
   let needsUpdate = false;
   const updateWallet = () => {
     if (needsUpdate) {
@@ -9556,48 +9638,54 @@ const makeMemoryWalletInner = async (ai, config, walletType, opts = {}) => {
     updateWallet();
   }, 0);
   const plugin = ai.props.state.plugins.currency[config.currencyInfo.pluginId];
-  const engine = await plugin.makeCurrencyEngine(walletInfo, {
-    callbacks: {
-      onAddressChanged: () => {},
-      onAddressesChecked: progressRatio => {
-        if (out.syncRatio === 1) return;
-        if (progressRatio === 1) {
-          syncRatio = progressRatio;
-          needsUpdate = true;
-        }
-      },
-      onNewTokens: tokenIds => {
-        const sortedTokenIds = tokenIds.sort((a, b) => a.localeCompare(b));
-        if (detectedTokenIds.length !== sortedTokenIds.length) {
+  const callbacks = {
+    onAddressChanged: () => {},
+    onAddressesChecked(totalRatio) {
+      callbacks.onSyncStatusChanged({
+        totalRatio
+      });
+    },
+    onNewTokens: tokenIds => {
+      const sortedTokenIds = tokenIds.sort((a, b) => a.localeCompare(b));
+      if (detectedTokenIds.length !== sortedTokenIds.length) {
+        detectedTokenIds = sortedTokenIds;
+        needsUpdate = true;
+        return;
+      }
+      for (let i = 0; i < sortedTokenIds.length; i++) {
+        if (detectedTokenIds[i] !== sortedTokenIds[i]) {
           detectedTokenIds = sortedTokenIds;
           needsUpdate = true;
           return;
         }
-        for (let i = 0; i < sortedTokenIds.length; i++) {
-          if (detectedTokenIds[i] !== sortedTokenIds[i]) {
-            detectedTokenIds = sortedTokenIds;
-            needsUpdate = true;
-            return;
-          }
-        }
-      },
-      onSeenTxCheckpoint: () => {},
-      onStakingStatusChanged: () => {},
-      onSubscribeAddresses: () => {},
-      onTokenBalanceChanged: (tokenId, balance) => {
-        if (balanceMap.get(tokenId) === balance) return;
-        balanceMap = new Map(balanceMap);
-        balanceMap.set(tokenId, balance);
+      }
+    },
+    onSeenTxCheckpoint: () => {},
+    onStakingStatusChanged: () => {},
+    onSubscribeAddresses: () => {},
+    onSyncStatusChanged(status) {
+      if (syncStatus.totalRatio === 1) return;
+      if (status.totalRatio === 1) {
+        syncStatus = status;
         needsUpdate = true;
-      },
-      onTransactions: () => {},
-      onTransactionsChanged: () => {},
-      onTxidsChanged: () => {},
-      onUnactivatedTokenIdsChanged: () => {},
-      onWcNewContractCall: () => {},
-      onBlockHeightChanged: () => {},
-      onBalanceChanged: () => {}
+      }
+    },
+    onTokenBalanceChanged: (tokenId, balance) => {
+      if (balanceMap.get(tokenId) === balance) return;
+      balanceMap = new Map(balanceMap);
+      balanceMap.set(tokenId, balance);
+      needsUpdate = true;
     },
+    onTransactions: () => {},
+    onTransactionsChanged: () => {},
+    onTxidsChanged: () => {},
+    onUnactivatedTokenIdsChanged: () => {},
+    onWcNewContractCall: () => {},
+    onBlockHeightChanged: () => {},
+    onBalanceChanged: () => {}
+  };
+  const engine = await plugin.makeCurrencyEngine(walletInfo, {
+    callbacks,
     customTokens: {
       ...config.customTokens
     },
@@ -9652,7 +9740,10 @@ const makeMemoryWalletInner = async (ai, config, walletType, opts = {}) => {
       return detectedTokenIds;
     },
     get syncRatio() {
-      return syncRatio;
+      return syncStatus.totalRatio;
+    },
+    get syncStatus() {
+      return syncStatus;
     },
     async changeEnabledTokenIds(tokenIds) {
       if (engine.changeEnabledTokenIds != null) {
@@ -10349,7 +10440,26 @@ function makeAccountApi(ai, accountId) {
     getWalletInfo: AccountSync.prototype.getWalletInfo,
     listWalletIds: AccountSync.prototype.listWalletIds,
     async splitWalletInfo(walletId, newWalletType) {
-      return await splitWalletInfo(ai, accountId, walletId, newWalletType);
+      const {
+        allWalletInfosFull
+      } = accountState();
+      const walletInfo = allWalletInfosFull.find(walletInfo => walletInfo.id === walletId);
+      if (walletInfo == null) throw new Error(`Invalid wallet id ${walletId}`);
+      const existingWallet = ai.props.output?.currency?.wallets[walletInfo.id]?.walletApi;
+
+      // The following check has not been needed since about 2021,
+      // when the currency plugins became responsible for listing
+      // their own splittable types, but keep it for safety:
+      if (walletInfo.type === 'wallet:bitcoin' && walletInfo.keys.format === 'bip49' && newWalletType === 'wallet:bitcoincash') {
+        throw new Error('Cannot split segwit-format Bitcoin wallets to Bitcoin Cash');
+      }
+      const [result] = await splitWalletInfo(ai, accountId, walletInfo, [{
+        walletType: newWalletType,
+        name: existingWallet?.name ?? undefined,
+        fiatCurrencyCode: existingWallet?.fiatCurrencyCode
+      }], true);
+      if (result.ok) return result.result.id;
+      throw result.error;
     },
     async listSplittableWalletTypes(walletId) {
       return await listSplittableWalletTypes(ai, accountId, walletId);
@@ -10590,19 +10700,6 @@ function getRawPrivateKey(ai, accountId, walletId) {
   }
   return info;
 }
-async function makeEdgeResult(promise) {
-  try {
-    return {
-      ok: true,
-      result: await promise
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      error
-    };
-  }
-}
 
 const initialCustomTokens = {};
 const blankSessionKey = {