Cloud-based custom scripts restoration

package.json

@@ -39,6 +39,7 @@
     "lottie-web": "^5.7.8",
     "marina-provider": "^2.0.0",
     "moment": "^2.29.4",
+    "octokit": "^2.0.14",
     "path-browserify": "^1.0.1",
     "postcss": "^7.0.35",
     "qrcode.react": "^1.0.1",

src/application/account.ts

@@ -19,6 +19,7 @@ import { Contract } from '@ionio-lang/ionio';
 import type { ZKPInterface } from 'liquidjs-lib/src/confidential';
 import { h2b } from './utils';
 import type { ChainSource } from '../domain/chainsource';
+import type { RestorationJSON, RestorationJSONDictionary } from '../domain/backup';
 
 export const MainAccountLegacy = 'mainAccountLegacy';
 export const MainAccount = 'mainAccount';
@@ -44,16 +45,6 @@ type AccountOpts = {
 
 type contractName = string;
 
-export type RestorationJSON = {
-  accountName: string;
-  artifacts: Record<contractName, Artifact>;
-  pathToArguments: Record<string, [contractName, Argument[]]>;
-};
-
-export type RestorationJSONDictionary = {
-  [network: string]: RestorationJSON[];
-};
-
 export function makeAccountXPub(seed: Buffer, basePath: string) {
   return bip32.fromSeed(seed).derivePath(basePath).neutered().toBase58();
 }

src/application/backup.ts

@@ -0,0 +1,69 @@
+import type { NetworkString } from 'marina-provider';
+import type { BackupConfig, BackupService } from '../domain/backup';
+import { BackupServiceType } from '../domain/backup';
+import type { AppRepository, WalletRepository } from '../domain/repository';
+import { BrowserSyncBackup } from '../port/browser-sync-backup-service';
+import { AccountFactory } from './account';
+import { GithubBackupService, isBackupGithubServiceConfig } from '../port/github-backup-service';
+
+export function makeBackupService(config: BackupConfig): BackupService {
+  switch (config.type) {
+    case BackupServiceType.BROWSER_SYNC:
+      return new BrowserSyncBackup();
+    case BackupServiceType.GITHUB:
+      if (!isBackupGithubServiceConfig(config))
+        throw new Error('Invalid backup service configuration for Github');
+      return new GithubBackupService(config);
+    default:
+      throw new Error('Invalid backup service configuration');
+  }
+}
+
+function isNetworkString(str: string): str is NetworkString {
+  return str === 'liquid' || str === 'testnet' || str === 'regtest';
+}
+
+export async function loadFromBackupServices(
+  appRepository: AppRepository,
+  walletRepository: WalletRepository,
+  backupServices: BackupService[]
+) {
+  const backupData = await Promise.all(backupServices.map((service) => service.load()));
+
+  const chainSourceLiquid = await appRepository.getChainSource('liquid');
+  const chainSourceTestnet = await appRepository.getChainSource('testnet');
+  const chainSourceRegtest = await appRepository.getChainSource('regtest');
+  const chainSource = (network: string) =>
+    network === 'liquid'
+      ? chainSourceLiquid
+      : network === 'testnet'
+      ? chainSourceTestnet
+      : chainSourceRegtest;
+
+  try {
+    const accountFactory = await AccountFactory.create(walletRepository);
+
+    for (const { ionioAccountsRestorationDictionary } of backupData) {
+      for (const [network, restorations] of Object.entries(ionioAccountsRestorationDictionary)) {
+        if (!isNetworkString(network)) continue;
+        const chain = chainSource(network);
+        if (!chain) continue;
+
+        for (const restoration of restorations) {
+          try {
+            const account = await accountFactory.make(network, restoration.accountName);
+            await account.restoreFromJSON(chain, restoration);
+          } catch (e) {
+            console.error(e);
+          }
+        }
+      }
+    }
+  } finally {
+    await Promise.all([
+      chainSourceLiquid?.close(),
+      chainSourceTestnet?.close(),
+      chainSourceRegtest?.close(),
+    ]).catch(console.error);
+  }
+}

src/background/background-script.ts

@@ -25,6 +25,7 @@ import { BlockHeadersAPI } from '../infrastructure/storage/blockheaders-reposito
 import type { ChainSource } from '../domain/chainsource';
 import { WalletRepositoryUnblinder } from '../application/unblinder';
 import { Transaction } from 'liquidjs-lib';
+import { BackupSyncer } from './backup-syncer';
 
 // manifest v2 needs BrowserAction, v3 needs action
 const action = Browser.browserAction ?? Browser.action;
@@ -42,7 +43,7 @@ const backgroundPort = getBackgroundPortImplementation();
 
 const walletRepository = new WalletStorageAPI();
 const appRepository = new AppStorageAPI();
-const assetRepository = new AssetStorageAPI(walletRepository);
+const assetRepository = new AssetStorageAPI();
 const taxiRepository = new TaxiStorageAPI(assetRepository, appRepository);
 const blockHeadersRepository = new BlockHeadersAPI();
 
@@ -59,6 +60,7 @@ const subscriberService = new SubscriberService(
   blockHeadersRepository
 );
 const taxiService = new TaxiUpdater(taxiRepository, appRepository, assetRepository);
+const backupSyncerService = new BackupSyncer(appRepository, walletRepository);
 
 let started = false;
 
@@ -77,11 +79,17 @@ async function startBackgroundServices() {
   if (started) return;
   started = true;
   await walletRepository.unlockUtxos(); // unlock all utxos at startup
-  await Promise.allSettled([
+  const results = await Promise.allSettled([
     updaterService.start(),
     subscriberService.start(),
     Promise.resolve(taxiService.start()),
+    backupSyncerService.start(),
   ]);
+  results.forEach((result) => {
+    if (result.status === 'rejected') {
+      console.error(result.reason);
+    }
+  });
 }
 
 async function restoreTask(restoreMessage: RestoreMessage): Promise<void> {
@@ -116,7 +124,17 @@ async function restoreTask(restoreMessage: RestoreMessage): Promise<void> {
 
 async function stopBackgroundServices() {
   started = false;
-  await Promise.allSettled([updaterService.stop(), subscriberService.stop(), taxiService.stop()]);
+  const results = await Promise.allSettled([
+    updaterService.stop(),
+    subscriberService.stop(),
+    taxiService.stop(),
+    backupSyncerService.stop(),
+  ]);
+  results.forEach((result) => {
+    if (result.status === 'rejected') {
+      console.error(result.reason);
+    }
+  });
 }
 
 /**

src/background/backup-syncer.ts

@@ -0,0 +1,95 @@
+import { AccountType, isIonioScriptDetails } from 'marina-provider';
+import Browser from 'webextension-polyfill';
+import { AccountFactory } from '../application/account';
+import { loadFromBackupServices, makeBackupService } from '../application/backup';
+import type { RestorationJSONDictionary } from '../domain/backup';
+import type { AppRepository, WalletRepository } from '../domain/repository';
+
+export class BackupSyncer {
+  static ALARM = 'backup-syncer';
+
+  private closeFn: () => Promise<void> = () => Promise.resolve();
+
+  constructor(private appRepository: AppRepository, private walletRepository: WalletRepository) {}
+
+  private async loadBackupData() {
+    const backupConfigs = await this.appRepository.getBackupServiceConfigs();
+    const backupServices = backupConfigs.map(makeBackupService);
+    await loadFromBackupServices(this.appRepository, this.walletRepository, backupServices);
+  }
+
+  private async saveBackupData() {
+    const restoration: RestorationJSONDictionary = {
+      liquid: [],
+      testnet: [],
+      regtest: [],
+    };
+    const allAccounts = await this.walletRepository.getAccountDetails();
+    const ionioAccounts = Object.values(allAccounts).filter(
+      ({ type }) => type === AccountType.Ionio
+    );
+    const factory = await AccountFactory.create(this.walletRepository);
+
+    for (const details of ionioAccounts) {
+      for (const net of details.accountNetworks) {
+        const account = await factory.make(net, details.accountID);
+        const restorationJSON = await account.restorationJSON();
+        restoration[net].push(restorationJSON);
+      }
+    }
+
+    const backupConfigs = await this.appRepository.getBackupServiceConfigs();
+    const backupServices = backupConfigs.map(makeBackupService);
+    const results = await Promise.allSettled([
+      ...backupServices.map((service) =>
+        service.save({ ionioAccountsRestorationDictionary: restoration })
+      ),
+    ]);
+
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        console.error(result.reason);
+      }
+    }
+  }
+
+  async start() {
+    this.closeFn = () => Promise.resolve();
+    const closeFns: (() => void | Promise<void>)[] = [];
+
+    // set up onNewScript & onNetworkChanged callbacks triggering backup saves
+    closeFns.push(
+      this.walletRepository.onNewScript(async (_, scriptDetails) => {
+        if (isIonioScriptDetails(scriptDetails)) {
+          await this.saveBackupData();
+        }
+      })
+    );
+
+    closeFns.push(
+      this.appRepository.onNetworkChanged(async () => {
+        await this.saveBackupData();
+      })
+    );
+
+    // set up an alarm triggering backup loads
+    Browser.alarms.create(BackupSyncer.ALARM, { periodInMinutes: 10 });
+    Browser.alarms.onAlarm.addListener(async (alarm: Browser.Alarms.Alarm) => {
+      if (alarm.name !== BackupSyncer.ALARM) return;
+      await this.loadBackupData();
+    });
+    closeFns.push(async () => {
+      await Browser.alarms.clear(BackupSyncer.ALARM);
+    });
+
+    this.closeFn = async () => {
+      await Promise.all(closeFns.map((fn) => Promise.resolve(fn())));
+    };
+    await this.loadBackupData(); // load backup data on start
+  }
+
+  async stop() {
+    await this.saveBackupData(); // save backup data on stop
+    await this.closeFn();
+  }
+}

src/content/marina/marinaBroker.ts

@@ -82,7 +82,7 @@ export default class MarinaBroker extends Broker<keyof Marina> {
     this.hostname = hostname;
     this.walletRepository = new WalletStorageAPI();
     this.appRepository = new AppStorageAPI();
-    this.assetRepository = new AssetStorageAPI(this.walletRepository);
+    this.assetRepository = new AssetStorageAPI();
     this.taxiRepository = new TaxiStorageAPI(this.assetRepository, this.appRepository);
     this.popupsRepository = new PopupsStorageAPI();
   }

src/domain/backup.ts

@@ -0,0 +1,38 @@
+import type { Argument, Artifact } from '@ionio-lang/ionio';
+
+type contractName = string;
+
+export type RestorationJSON = {
+  accountName: string;
+  artifacts: Record<contractName, Artifact>;
+  pathToArguments: Record<string, [contractName, Argument[]]>;
+};
+
+export type RestorationJSONDictionary = {
+  [network: string]: RestorationJSON[];
+};
+
+// attach a version number for later updates
+export type BackupDataVersion = 0;
+
+export interface BackupData {
+  version: BackupDataVersion;
+  ionioAccountsRestorationDictionary: RestorationJSONDictionary;
+}
+
+export interface BackupService {
+  save(data: Partial<BackupData>): Promise<void>;
+  load(): Promise<BackupData>;
+  delete(): Promise<void>;
+  initialize(): Promise<void>;
+}
+
+export enum BackupServiceType {
+  BROWSER_SYNC = 'browser-sync',
+  GITHUB = 'github',
+}
+
+export interface BackupConfig {
+  ID: string; // Unique ID for the backup service
+  type: BackupServiceType;
+}

src/domain/repository.ts

@@ -13,7 +13,6 @@ import type { UnblindingData, CoinSelection, TxDetails, UnblindedOutput } from '
 import Browser from 'webextension-polyfill';
 import type { Encrypted } from './encryption';
 import { encrypt } from './encryption';
-import type { RestorationJSONDictionary } from '../application/account';
 import {
   Account,
   MainAccount,
@@ -24,6 +23,7 @@ import {
 import { mnemonicToSeed } from 'bip39';
 import { SLIP77Factory } from 'slip77';
 import type { BlockHeader, ChainSource } from './chainsource';
+import type { BackupConfig, RestorationJSONDictionary } from './backup';
 
 export interface AppStatus {
   isMnemonicVerified: boolean;
@@ -73,6 +73,10 @@ export interface AppRepository {
   onNetworkChanged: EventEmitter<[NetworkString]>;
   onIsAuthenticatedChanged: EventEmitter<[authenticated: boolean]>;
 
+  addBackupServiceConfig(...config: BackupConfig[]): Promise<void>;
+  removeBackupServiceConfig(ID: BackupConfig['ID']): Promise<void>;
+  getBackupServiceConfigs(): Promise<BackupConfig[]>;
+
   /** loaders **/
   restorerLoader: Loader;
   updaterLoader: Loader;
@@ -182,6 +186,8 @@ export interface OnboardingRepository {
   setOnboardingPasswordAndMnemonic(password: string, mnemonic: string): Promise<void>;
   setRestorationJSONDictionary(json: RestorationJSONDictionary): Promise<void>;
   getRestorationJSONDictionary(): Promise<RestorationJSONDictionary | undefined>;
+  setBackupServicesConfiguration(configs: BackupConfig[]): Promise<void>;
+  getBackupServicesConfiguration(): Promise<BackupConfig[] | undefined>;
   setIsFromPopupFlow(mnemonicToBackup: string): Promise<void>;
   flush(): Promise<void>; // flush all data
 }

src/extension/components/github-backup-form.tsx

@@ -0,0 +1,51 @@
+import * as Yup from 'yup';
+import type { FormikProps } from 'formik';
+import { withFormik } from 'formik';
+import Input from './input';
+import Button from './button';
+
+interface FormProps {
+  onSubmit: (githubToken: string) => void;
+}
+
+interface FormValues {
+  githubToken: string;
+}
+
+const Form = (props: FormikProps<FormValues>) => {
+  return (
+    <form onSubmit={props.handleSubmit} className="w-full mt-8">
+      <Input
+        {...props}
+        name="githubToken"
+        placeholder="paste your GitHub token here"
+        type="textarea"
+        value={props.values.githubToken}
+        title="GitHub Token"
+      />
+      <div className="text-right">
+        <Button
+          className="-mt-2 text-base"
+          disabled={props.isSubmitting || !!(props.errors.githubToken && props.touched.githubToken)}
+          type="submit"
+        >
+          OK
+        </Button>
+      </div>
+    </form>
+  );
+};
+
+const GithubBackupForm = withFormik<FormProps, FormValues>({
+  mapPropsToValues: () => ({
+    githubToken: '',
+  }),
+  validationSchema: Yup.object().shape({
+    githubToken: Yup.string().required('Required'),
+  }),
+  handleSubmit: (values, { props }) => {
+    props.onSubmit(values.githubToken);
+  },
+})(Form);
+
+export default GithubBackupForm;