Feat/merge refactor

packages/common-types/src/baseTypes/aggregateTypes.ts

@@ -47,7 +47,8 @@ export type RefreshMiddlewareMap = {
 };
 
 export type ReconstructKeyMiddlewareMap = {
-  [moduleName: string]: () => Promise<BN[]>;
+  // eslint-disable-next-line no-use-before-define
+  [moduleName: string]: (tkey: ITKeyApi) => Promise<BN[]>;
 };
 
 export type ShareSerializationMiddleware = {
@@ -78,6 +79,24 @@ export interface IMetadata extends ISerializable {
 
   nonce: number;
 
+  tssNonces?: {
+    [tssTag: string]: number;
+  };
+
+  tssPolyCommits?: {
+    [tssTag: string]: Point[];
+  };
+
+  factorPubs?: {
+    [tssTag: string]: Point[];
+  };
+
+  factorEncs?: {
+    [tssTag: string]: {
+      [factorPubID: string]: FactorEnc;
+    };
+  };
+
   getShareIndexesForPolynomial(polyID: PolynomialID): string[];
   getLatestPublicPolynomial(): PublicPolynomial;
   addTSSData(tssData: {
@@ -142,6 +161,8 @@ export type KeyDetails = {
   threshold: number;
   totalShares: number;
   shareDescriptions: ShareDescriptionMap;
+  deviceShare?: ShareStore;
+  userShare?: ShareStore;
 };
 
 export type TKeyArgs = {
@@ -252,8 +273,18 @@ export type LocalMetadataTransitions = [LocalTransitionShares, LocalTransitionDa
 
 export interface ITKeyApi {
   getMetadata(): IMetadata;
+  getServiceProvider(): IServiceProvider;
   getStorageLayer(): IStorageLayer;
-  initialize(params: { input?: ShareStore; importKey?: BN; neverInitializeNewKey?: boolean }): Promise<KeyDetails>;
+  initialize(params: {
+    withShare?: ShareStore;
+    importKey?: BN;
+    neverInitializeNewKey?: boolean;
+    transitionMetadata?: IMetadata;
+    previouslyFetchedCloudMetadata?: IMetadata;
+    previousLocalMetadataTransitions?: LocalMetadataTransitions;
+    delete1OutOf1?: boolean;
+    // input?: ShareStore; importKey?: BN; neverInitializeNewKey?: boolean
+  }): Promise<KeyDetails>;
   catchupToLatestShare(params: {
     shareStore: ShareStore;
     polyID?: string;
@@ -267,7 +298,7 @@ export interface ITKeyApi {
     moduleName: string,
     middleware: (generalStore: unknown, oldShareStores: ShareStoreMap, newShareStores: ShareStoreMap) => unknown
   ): void;
-  _addReconstructKeyMiddleware(moduleName: string, middleware: () => Promise<Array<BN>>): void;
+  _addReconstructKeyMiddleware(moduleName: string, middleware: (tkey: ITKeyApi) => Promise<Array<BN>>): void;
   _addShareSerializationMiddleware(
     serialize: (share: BN, type: string) => Promise<unknown>,
     deserialize: (serializedShare: unknown, type: string) => Promise<BN>

packages/common-types/src/baseTypes/commonTypes.ts

@@ -45,6 +45,14 @@ export interface TorusServiceProviderArgs extends ServiceProviderArgs {
   nodePubKeys?: PointHex[];
 }
 
+export enum TkeyStatus {
+  NOT_INITIALIZED = "NOT_INITIALIZED",
+  // READ MODE
+  INITIALIZED = "INITIALIZED",
+  // WRITE MODE
+  RECONSTRUCTED = "RECONSTRUCTED",
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type StringifiedType = Record<string, any>;
 

packages/core/src/core.ts

@@ -48,6 +48,7 @@ import {
   ShareStorePolyIDShareIndexMap,
   StringifiedType,
   TKeyArgs,
+  TkeyStatus,
   TkeyStoreItemType,
   toPrivKeyECC,
 } from "@tkey/common-types";
@@ -220,6 +221,23 @@ class ThresholdKey implements ITKey {
     throw CoreError.metadataUndefined();
   }
 
+  getServiceProvider(): IServiceProvider {
+    if (typeof this.serviceProvider !== "undefined") {
+      return this.serviceProvider;
+    }
+
+    throw CoreError.default("serviceProvider undefined");
+  }
+
+  getTkeyStatus(): TkeyStatus {
+    // NOT INITIALIZED
+    if (!this.metadata) return TkeyStatus.NOT_INITIALIZED;
+    // READ MODE
+    if (!this.privKey) return TkeyStatus.INITIALIZED;
+    // WRITE MODE
+    return TkeyStatus.RECONSTRUCTED;
+  }
+
   async initialize(params?: {
     withShare?: ShareStore;
     importKey?: BN;
@@ -232,7 +250,7 @@ class ThresholdKey implements ITKey {
     deviceTSSShare?: BN;
     deviceTSSIndex?: number;
     factorPub?: Point;
-  }): Promise<KeyDetails> {
+  }): Promise<KeyDetails & { deviceShare?: ShareStore; userShare?: ShareStore }> {
     // setup initial params/states
     const p = params || {};
 
@@ -287,7 +305,7 @@ class ThresholdKey implements ITKey {
           throw CoreError.default("key has not been generated yet");
         }
         // no metadata set, assumes new user
-        await this._initializeNewKey({
+        const result = await this._initializeNewKey({
           initializeModules: true,
           importedKey: importKey,
           delete1OutOf1: p.delete1OutOf1,
@@ -296,14 +314,47 @@ class ThresholdKey implements ITKey {
           const { factorEncs, factorPubs, tssPolyCommits } = await this._initializeNewTSSKey(this.tssTag, deviceTSSShare, factorPub, deviceTSSIndex);
           this.metadata.addTSSData({ tssTag: this.tssTag, tssNonce: 0, tssPolyCommits, factorPubs, factorEncs });
         }
-        return this.getKeyDetails();
+        const keyDetail = this.getKeyDetails();
+        keyDetail.deviceShare = result.deviceShare;
+        keyDetail.userShare = result.userShare;
+
+        return keyDetail;
       }
       // else we continue with catching up share and metadata
       shareStore = ShareStore.fromJSON(rawServiceProviderShare);
     } else {
       throw CoreError.default("Input is not supported");
     }
 
+    return this.initializeWithShareStore({
+      shareStore,
+      transitionMetadata,
+      previouslyFetchedCloudMetadata,
+      previousLocalMetadataTransitions,
+      useTSS,
+      deviceTSSShare,
+      factorPub,
+    });
+  }
+
+  async initializeWithShareStore(params: {
+    shareStore: ShareStore;
+    transitionMetadata?: Metadata;
+    previouslyFetchedCloudMetadata?: Metadata;
+    previousLocalMetadataTransitions?: LocalMetadataTransitions;
+    useTSS?: boolean;
+    deviceTSSShare?: BN;
+    factorPub?: Point;
+  }) {
+    const { shareStore, transitionMetadata, previouslyFetchedCloudMetadata, previousLocalMetadataTransitions, useTSS, deviceTSSShare, factorPub } =
+      params;
+
+    const previousLocalMetadataTransitionsExists =
+      previousLocalMetadataTransitions && previousLocalMetadataTransitions[0].length > 0 && previousLocalMetadataTransitions[1].length > 0;
+    const reinitializing = transitionMetadata && previousLocalMetadataTransitionsExists; // are we reinitializing the SDK?
+    // in the case we're reinitializing whilst newKeyAssign has not been synced
+    const reinitializingWithNewKeyAssign = reinitializing && previouslyFetchedCloudMetadata === undefined;
+
     // We determine the latest metadata on the SDK and if there has been
     // needed transitions to include
     let currentMetadata: Metadata;
@@ -354,7 +405,9 @@ class ThresholdKey implements ITKey {
     if (useTSS) {
       if (!this.metadata.tssPolyCommits[this.tssTag]) {
         // if tss shares have not been created for this tssTag, create new tss sharing
-        await this._initializeNewTSSKey(this.tssTag, deviceTSSShare, factorPub);
+        const { factorEncs, factorPubs, tssPolyCommits } = await this._initializeNewTSSKey(this.tssTag, deviceTSSShare, factorPub);
+        this.metadata.addTSSData({ tssTag: this.tssTag, tssNonce: 0, tssPolyCommits, factorPubs, factorEncs });
+        this._syncShareMetadata();
       }
     }
 
@@ -578,7 +631,7 @@ class ThresholdKey implements ITKey {
       await Promise.all(
         Object.keys(this._reconstructKeyMiddleware).map(async (x) => {
           if (Object.prototype.hasOwnProperty.call(this._reconstructKeyMiddleware, x)) {
-            const extraKeys = await this._reconstructKeyMiddleware[x]();
+            const extraKeys = await this._reconstructKeyMiddleware[x](this);
             returnObject[x] = extraKeys;
             returnObject.allKeys.push(...extraKeys);
           }
@@ -1434,6 +1487,7 @@ class ThresholdKey implements ITKey {
 
     const shareArray = this.getAllShareStoresForLatestPolynomial().map((x) => x.share.share);
     await this.syncMultipleShareMetadata(shareArray, adjustScopedStore);
+    if (!this.manualSync) this.syncLocalMetadataTransitions();
   }
 
   async syncMultipleShareMetadata(shares: BN[], adjustScopedStore?: (ss: unknown) => unknown): Promise<void> {
@@ -1471,7 +1525,7 @@ class ThresholdKey implements ITKey {
     this._refreshMiddleware[moduleName] = middleware;
   }
 
-  _addReconstructKeyMiddleware(moduleName: string, middleware: () => Promise<BN[]>): void {
+  _addReconstructKeyMiddleware(moduleName: string, middleware: (tkey: ITKeyApi) => Promise<BN[]>): void {
     this._reconstructKeyMiddleware[moduleName] = middleware;
   }
 
@@ -1697,6 +1751,7 @@ class ThresholdKey implements ITKey {
   getApi(): ITKeyApi {
     return {
       getMetadata: this.getMetadata.bind(this),
+      getServiceProvider: this.getServiceProvider.bind(this),
       getStorageLayer: this.getStorageLayer.bind(this),
       initialize: this.initialize.bind(this),
       catchupToLatestShare: this.catchupToLatestShare.bind(this),

packages/default/package.json

@@ -42,14 +42,16 @@
     "@tkey/share-serialization": "^8.1.0-alpha.0",
     "@tkey/share-transfer": "^8.1.0-alpha.0",
     "@tkey/storage-layer-torus": "^8.1.0-alpha.0",
+    "@tkey/mnemonic": "^8.1.0-alpha.0",
     "@toruslabs/eccrypto": "^2.1.1",
-    "@toruslabs/rss-client": "^1.4.1",
     "bn.js": "^5.2.1"
   },
   "devDependencies": {
     "@tkey/private-keys": "^8.1.0-alpha.0",
     "@tkey/seed-phrase": "^8.1.0-alpha.0",
     "@toruslabs/http-helpers": "^4.0.0",
+    "@toruslabs/rss-client": "^1.4.1",
+    "@tkey/tss": "^8.1.0-alpha.0",
     "jsrsasign": "^10.6.1",
     "web3-utils": "^1.8.1"
   },

packages/default/test/helpers.js

@@ -51,13 +51,16 @@ export function getServiceProvider(params) {
   return new ServiceProviderBase({ postboxKey: isEmptyProvider ? null : PRIVATE_KEY });
 }
 
+const MockServers = [new MockServer(), new MockServer(), new MockServer(), new MockServer(), new MockServer()];
+
 export async function setupTSSMocks(opts) {
-  let { serviceProvider, verifierName, verifierId, maxTSSNonceToSimulate, tssTag } = opts;
+  let { serviceProvider, verifierName, verifierId, maxTSSNonceToSimulate, tssTag, postboxKey } = opts;
   tssTag = tssTag || "default";
   serviceProvider._setVerifierNameVerifierId(verifierName, verifierId);
   const vid = serviceProvider.getVerifierNameVerifierId();
   maxTSSNonceToSimulate = maxTSSNonceToSimulate || 1;
-  const serverEndpoints = [new MockServer(), new MockServer(), new MockServer(), new MockServer(), new MockServer()];
+  // const serverEndpoints = [new MockServer(), new MockServer(), new MockServer(), new MockServer(), new MockServer()];
+  const serverEndpoints = MockServers;
   const serverCount = serverEndpoints.length;
   const serverPrivKeys = [];
   for (let i = 0; i < serverCount; i++) {
@@ -92,10 +95,17 @@ export async function setupTSSMocks(opts) {
         });
       })
     );
-    serviceProvider._setTSSPubKey("default", j, new Point(dkg2Pub.x, dkg2Pub.y));
+    serviceProvider._setTSSPubKey(tssTag, j, new Point(dkg2Pub.x, dkg2Pub.y));
   }
 
   serviceProvider._setTSSNodeDetails(serverEndpoints, serverPubKeys, serverThreshold);
+  serviceProvider.rssNodeDetails = { ...serviceProvider.tssNodeDetails };
+
+  // update new serviceprovider postbox key
+  if (!postboxKey) {
+    const postboxKeyGenerated = new BN(generatePrivate());
+    serviceProvider.postboxKey = postboxKeyGenerated.toString(16, 64);
+  }
 
   return {
     serverEndpoints,
@@ -182,3 +192,47 @@ export async function assignTssDkgKeys(opts) {
     // serverDKGPubKeys,
   };
 }
+
+export async function setupTSS(opts) {
+  const { serviceProvider, verifierName, verifierId, maxTSSNonceToSimulate, tssTag, MOCK_RSS, postboxKey } = opts;
+  if (MOCK_RSS) {
+    const { serverEndpoints, serverPubKeys, serverDKGPrivKeys, serverDKGPubKeys } = await setupTSSMocks({
+      serviceProvider,
+      verifierName,
+      verifierId,
+      maxTSSNonceToSimulate,
+      tssTag,
+      postboxKey,
+    });
+    const signatures = "signature";
+    return {
+      signatures,
+      serverDKGPrivKeys,
+    };
+  }
+
+  // get signature and postboxkey from nodes
+  const { signatures, postboxkey } = await fetchPostboxKeyAndSigs({
+    serviceProvider,
+    verifierName,
+    verifierId,
+  });
+  serviceProvider.postboxKey = postboxkey;
+  const { serverDKGPrivKeys } = await assignTssDkgKeys({
+    serviceProvider,
+    verifierName,
+    verifierId,
+    maxTSSNonceToSimulate,
+    tssTag,
+  });
+
+  return {
+    signatures,
+    serverDKGPrivKeys,
+  };
+}
+
+export const generateVerifierId = (prefix = "") => {
+  const randomkey = generatePrivate().toString("hex");
+  return `${prefix}${randomkey}@mail.com`;
+};